﻿#pragma once
namespace LK
{
	namespace Collection
	{
		template<class dest, class source, bool isClass = IsClassOrUnion<dest>::V || IsClassOrUnion<source>::V>struct ElementConstruction
		{
			//构造方法
			static inline void Construct(dest* pDest, source* pSource, index_t len) { while (len-- > 0)placementnew<dest, source&>(pDest++, *pSource++); }
			//构造方法
			static inline void ConstructWith(dest* pDest, source &s, index_t len) { while (len-- > 0)placementnew<dest, source&>(pDest++, s); }
			//默认构造
			static inline void DefaultConstruct(dest* p, index_t len) { while (len-- > 0) { placementnew<dest>(p++); } }
			//移动构造
			static inline void MoveConstruct(dest* pDest, source* pSource, index_t len)
			{
				if (pDest < pSource)
				{
#ifdef SUPPORT_RIGHT_VALUE_REFERENCE
					while (len-- != 0) { placementnew<dest, source&&>(pDest++, (source&&)*pSource); (pSource++)->source::~source(); }
#else
					while (len-- != 0) { placementnew<dest, source&>(pDest++, *pSource); (pSource++)->source::~source(); }
#endif
				}
				else
				{
#ifdef SUPPORT_RIGHT_VALUE_REFERENCE
					while (len-- != 0) { placementnew<dest, source&&>(pDest + len, (source&&)pSource[len]); (pSource + len)->source::~source(); }
#else
					while (len-- != 0) { placementnew<dest, source&>(pDest + len, pSource[len]); (pSource + len)->source::~source(); }
#endif
				}
			}
			//析构
			static inline void Deconstruct(dest* p, index_t len) { while (len-- > 0) { (p++)->dest::~dest(); } }
			//析构
			static inline void Deconstruct(dest* p) { p->dest::~dest(); }
			//复制
			static inline void CopyMethod(dest*pDest, source*pSource, index_t len)
			{
				while (len--) { *pDest++ = *pSource++; }
			}
		};
		template<class dest, class source>struct ElementConstruction<dest, source, false>
		{
			//构造方法
			static inline void Construct(dest* pDest, source* pSource, index_t len) { }
			//构造方法
			static inline void ConstructWith(dest* pDest, source &s, index_t len) { while (len-- > 0)*pDest++ = s; }
			//默认构造
			static inline void DefaultConstruct(dest* p, index_t len) { }
			//移动构造
			static inline void MoveConstruct(dest* pDest, source* pSource, index_t len)
			{
				if (pDest < pSource)
				{
					while (len-- != 0) { *pDest++ = *pSource; }
				}
				else
				{
					while (len-- != 0) { pDest[len] = pSource[len]; }
				}
			}
			//析构
			static inline void Deconstruct(dest* p, index_t len) { }
			//析构
			static inline void Deconstruct(dest* p) {}
			//复制
			static inline void CopyMethod(dest*pDest, source*pSource, index_t len) { while (len--) { *pDest++ = *pSource++; } }
		};
		template<class T>struct ElementConstruction<T, T, false>
		{
			//构造方法
			static inline void Construct(T* pDest, T* pSource, index_t len) { }
			//构造方法
			static inline void ConstructWith(T* pDest, T &source, index_t len) { while (len-- > 0)*pDest++ = source; }
			//默认构造
			static inline void DefaultConstruct(T* p, index_t len) { }
			//移动构造
			static inline void MoveConstruct(T* pDest, T* pSource, index_t len)
			{
				Memory::Move(pDest, pSource, sizeof(T)*len);
			}
			//析构
			static inline void Deconstruct(T* p, index_t len) { }
			//析构
			static inline void Deconstruct(T* p) {}
			//复制
			static inline void CopyMethod(T*pDest, T*pSource, index_t len) { Memory::Copy(pDest, pSource, sizeof(T)*len); }
		};

		//数组接口
		struct IArrays :virtual ICollections, virtual ISortables,virtual ICloneables
		{
		protected:
			//构造方法
			template<class T1, class T2>static inline void Construct(T1* pDest, T2* pSource, index_t len) { ElementConstruction<T1, T2>::Construct(pDest, pSource, len); }
			//构造方法
			template<class T1, class T2>static inline void ConstructWith(T1* pDest, const T2 &source, index_t len) { ElementConstruction<T1, const T2>::ConstructWith(pDest, source, len); }
			template<class T1, class T2>static inline void ConstructWith(T1* pDest, T2 &source, index_t len) { ElementConstruction<T1, T2>::ConstructWith(pDest, source, len); }
			//默认构造
			template<class LT>static inline void DefaultConstruct(LT* p, index_t len) { ElementConstruction<LT, LT>::DefaultConstruct(p, len); }
			//移动构造
			template<class T, class LT>static inline void MoveConstruct(T* pDest, LT* pSource, index_t len)
			{
				ElementConstruction<T, LT>::MoveConstruct(pDest, pSource, len);
			}
			//析构
			template<class LT>static inline void Deconstruct(LT* p, index_t len) { ElementConstruction<LT, LT>::Deconstruct(p, len); }
			//析构
			template<class LT>static inline void Deconstruct(LT* p) { ElementConstruction<LT, LT>::Deconstruct(p); }
			//复制
			template<class T, class LT>static inline void CopyMethod(T*pDest, const LT*pSource, index_t len)
			{
				ElementConstruction<T, const LT>::CopyMethod(pDest, pSource, len);
			}
			template<class T, class LT>static inline void CopyMethod(T*pDest, LT*pSource, index_t len)
			{
				ElementConstruction<T, LT>::CopyMethod(pDest, pSource, len);
			}
		public:
			IMETHODS(PArrays, IArrays);
			/**
			@brief 获取数组元素所占字节空间*/
			virtual index_t GetLengthOfBytes()const = 0;
			/**
			@brief 获取数组内容首地址*/
			virtual void const* GetData()const = 0;
			/**@brief 产生浅表副本*/
			virtual IArrays* Clone()const = 0;
			/**
			@brief 清理数组*/
			virtual void clear() = 0;
			/**@brief 反转容器中的元素，并返回容器引用*/
			virtual IArrays& Reverse() = 0;
			/**
			@brief 调整大小，返回调整后数组元素最大大小*/
			virtual index_t Resize(index_t len) { return 0; }
			//检查索引
			inline bool CheckIndex(index_t index)const
			{
				if (index < 0)throw PInvalidArgumentException(L"数组下标小于0");
				if (index > size())throw PIndexOutOfRangeException(L"数组下标大于元素总数");
				return index == size();
			}
			inline bool CheckIndex(index_t startIndex, index_t len)const
			{
				if (startIndex < 0 || len < 0)throw PInvalidArgumentException(L"数组下标小于0");
				if (startIndex + len > size())throw PIndexOutOfRangeException(L"数组下标大于元素总数");
				return len == 0;
			}
			//检查迭代器
			template<class LT>inline bool CheckIterator(const LT& iter)const
			{
				return CheckIndex(iter - (LT*)GetData());
			}
			template<class LT>inline bool CheckIterator(const LT& startIter, const LT& endIter)const
			{
				return CheckIndex(startIter - (LT*)GetData(), endIter - startIter);
			}
		};

		struct PArrays :PCollections
		{
			PIMETHODS(PArrays, IArrays)

				/**@brief 调整数组大小*/
				index_t Resize(index_t len) { return Ptr()->Resize(len); }
		};


		/**
		@brief 表示一个数组*/
		template<class T>struct IArray : IArrays
		{
		public:
			typedef ArrayIterator<T> iterator;
			typedef ArrayIterator<T const> const_iterator;
			typedef ReverseArrayIterator< T> reverse_iterator;
			typedef ReverseArrayIterator<T const> const_reverse_iterator;
			typedef T value_type;
			/**
			@brief 通用接口方法*/
			IMETHODS(PArray<T>, IArray)
			/**
			@brief 获取数组当前最大容量
			@note 当数组元素数不大于最大容量，而且两者之差不大于MaxUnusedLength时，对象存储区域将不会进行内存的重新调整*/
			virtual index_t GetMaxSize()const = 0;
			/**@brief 产生浅表副本*/
			virtual IArray* Clone()const = 0;
			/**
			@brief 获取数组按字节计算的长度*/
			index_t GetLengthOfBytes()const { return size()*sizeof(T); }
			/**
			@brief 迭代器，位置定位到第一个元素*/
			iterator begin() { return iterator(operator T*const()); }
			/**
			@brief 迭代器，位置定位到第一个元素*/
			const_iterator begin()const { return const_iterator(operator const T*const()); }
			/**
			@brief 获取最后一个元素的引用
			@note 如果容器元素数为NULL将抛出PIndexOutOfRangeException*/
			T& back() { if (size() == 0)throw PIndexOutOfRangeException(L"数组无元素"); return (operator T*const())[size() - 1]; }
			/**
			@brief 获取最后一个元素的引用
			@note 如果容器元素数为NULL将抛出PIndexOutOfRangeException*/
			T const& back()const { if (size() == 0)throw PIndexOutOfRangeException(L"数组无元素");  return (operator const T*const())[size() - 1]; }
			/**
			@brief 获取指定下标的元素的引用
			@param [传入]参数index表示指定的下标
			@return 返回指定下标的元素引用
			@note 该函数会作越界检查*/
			T const& at(index_t index)const { if (CheckIndex(index))throw PIndexOutOfRangeException(); return getdata()[index]; }
			/**
			@brief 获取指定下标的元素的引用
			@param [传入]参数index表示指定的下标
			@return 返回指定下标的元素引用
			@note 该函数会作越界检查*/
			T& at(index_t index) { if (CheckIndex(index))throw PIndexOutOfRangeException(); return getdata()[index]; }
			/**
			@brief 迭代器，位置定位到最后一个元素*/
			reverse_iterator rbegin() { return size() != 0 ? getdata() + size() - 1 : (T*)NULL; }
			/**
			@brief 迭代器，位置定位到最后一个元素*/
			const_reverse_iterator rbegin()const { return size() != 0 ? getdata() + size() - 1 : (T*)NULL; }
			/**
			@brief 迭代器，位置定位到末尾*/
			iterator end() { return iterator(getdata() + size()); }
			/**
			@brief 迭代器，位置定位到末尾*/
			const_iterator end()const { return const_iterator(getdata() + size()); }
			/**
			@brief 迭代器，位置定位到起始*/
			reverse_iterator rend() { return reverse_iterator(size() != 0 ? getdata() + size() - 1 : (T*)NULL); }
			/**
			@brief 迭代器，位置定位到起始*/
			const_reverse_iterator rend()const { return const_reverse_iterator(size() != 0 ? getdata() + size() - 1 : (T*)NULL); }
			/**
			@brief 清理数组*/
			void clear() { Resize(0); }
			/**
			@brief 获取数组内容指针（T*）*/
			T* getdata()const { return (T*)GetData(); }
			/**
			@brief 直接转换成指针形式*/
			operator const T*const ()const { return (const T*)GetData(); }
			/**
			@brief 转换成指针形式*/
			operator T*const () { return (T*)GetData(); }
			/**
			@brief 析构函数*/
			~IArray() {}

#if _VC >1800
			/**
			@brief 直接转换成指针形式*/
			template<class LT>inline explicit operator const LT*const ()const { return (const LT*)(const T*const)*this; }
			/**
			@brief 转换成指针形式*/
			template<class LT>inline explicit operator LT*const () { return (LT*)(T*const)*this; }
#endif
			template<class AnyT>index_t CopyTo(IArray<AnyT>& pdata, index_t startIndex = 0, index_t destinationStartIndex = 0)const;
			/**
			@breif 将该数组的内容复制一部分到另一个数组，返回实际复制的元素数
			@param [模板,可选]参数AnyT表示目标数组的元素类型
			@param [写出]参数pdata表示目标数组
			@param [传入]参数startIndex表示本数组起始复制位置
			@param [传入]参数destinationStartIndex表示目标起始写入位置
			@param [传入]参数length表示复制元素数
			@return 返回实际写入元素数
			@note 该复制方法将进行逐个元素一一对应的复制*/
			template<class AnyT>index_t CopyTo(IArray<AnyT>& pdata, index_t startIndex, index_t destinationStartIndex, index_t length)const;
			/**
			@breif 将该数组的内容复制一部分到另一个数组，返回实际复制的字节数
			@param [模板,可选]参数AnyT表示目标数组的元素类型
			@param [写出]参数pdata表示目标数组
			@param [传入,可选]参数startIndex表示本数组起始复制字节位置，默认是0
			@param [传入,可选]参数destinationStartIndex表示目标起始写入字节位置，默认是0
			@return 返回实际复制的字节数
			@note 该复制方法将直接进行内存复制*/
			template<class AnyT>index_t CopyToByBytes(IArray<AnyT>& pdata, index_t startByte = 0, index_t destinationStartByte = 0)const;
			/**
			@breif 将该数组的内容复制一部分到另一个数组，返回实际复制的字节数
			@param [模板,可选]参数AnyT表示目标数组的元素类型
			@param [写出]参数pdata表示目标数组
			@param [传入]参数startIndex表示本数组起始复制字节位置
			@param [传入]参数destinationStartIndex表示目标起始写入字节位置
			@param [传入]参数lengthOfBytes复制字节数
			@return 返回实际复制的字节数
			@note 该复制方法将直接进行内存复制*/
			template<class AnyT>index_t CopyToByBytes(IArray<AnyT>& pdata, index_t startByte, index_t destinationStartByte, index_t lengthOfBytes)const;
			/**
			@brief 将数组中所有元素的值设置为t
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示设置目标值*/
			template<class AnyT>void ResetTo(const AnyT& t);
			/**
			@brief 将数组中指定的元素的值设置为t
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示设置目标值
			@param [传入]参数index表示设置起始位置
			@param [传入]参数t表示设置元素数量*/
			template<class AnyT>void ResetTo(const AnyT& t, index_t index, index_t length);
			/**
			@brief 在数组的指定位置插入元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数index表示插入位置
			@param [传入]参数t表示要插入的内容*/
			template<class AnyT>void Insert(index_t index, const AnyT&t);
			/**
			@brief 在对象已升序排序的前提下使用二分法进行插入
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数CompareFunctionType表示比较方法类型
			@param [传入]参数t表示要插入的内容
			@param [传入]参数compare提供数组元素与插入内容进行比较的方法
			@return 返回插入的位置*/
			template<class AnyT, class CompareFunctionType>index_t DichotomyInsertAsc(AnyT t, CompareFunctionType compareMethod);
			/**
			@brief 在对象已升序排序的前提下使用二分法进行插入
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示要插入的内容
			@return 返回插入的位置*/
			template<class AnyT>index_t DichotomyInsertAsc(AnyT t) { return DichotomyInsertAsc<AnyT, typename CompareMethodObject<T&, AnyT>::T>(t, CompareMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在数组的指定位置插入数组
			@param [模板,可选]参数AnyT表示xArray的元素数据类型
			@param [传入]参数index表示插入位置
			@param [传入]参数xArray表示要插入的数组*/
			template<class AnyT>void InsertArray(index_t index, const IArray<AnyT>&xArray);
			/**
			@brief 在数组的结尾附加元素
			@param [模板,可选]参数AnyT表示t的数据类型
			@param [传入]参数t表示附加的元素
			@note 该操作将使元素数+1*/
			template<class AnyT>void Append(const AnyT&t);
			/**
			@brief 在数组的结尾附加数组
			@param [模板,可选]参数AnyT表示xArray的元素数据类型
			@param [传入]参数xArray表示附加的数组
			@note 该操作将使元素数+xArray数组元素数*/
			template<class AnyT>void AppendArray(const IArray<AnyT>&xArray);
			/**
			@brief 移除指定位置以及其之后的元素
			@param [传入]参数startIndex表示指定的位置
			@note 该操作将使元素数变为startIndex
			@note 被移除部分元素被移除后是否立即析构跟type有关系*/
			void Remove(index_t startIndex);
			/**
			@brief 移除指定位置的元素
			@param [传入]参数startIndex表示指定的位置
			@note 该操作将使元素数-1*/
			void RemoveAt(index_t index);
			/**
			@brief 从指定位置起移除一定量的元素
			@param [传入]参数startIndex表示指定的位置
			@param [传入]参数length表示需要移除的元素数量
			@note 被移除部分元素被移除后是否立即析构跟type有关系*/
			void Remove(index_t startIndex, index_t length);
			/**
			@brief 移除数组指定区域中首个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入,可选]参数startIndex指示开始进行比较的位置
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回移除的元素所在位置.如果未移除任何元素，则返回-1*/
			template<class AnyT, class EqualFunctionType>index_t RemoveFirstOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod);
			/**
			@brief 移除数组指定区域中首个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t为指定的要移除的值
			@param [传入,可选]参数startIndex指示开始进行比较的位置，默认为0
			@return 返回移除的元素所在位置.如果未移除任何元素，则返回-1*/
			template<class AnyT>index_t RemoveFirstOf(AnyT t, index_t startIndex = 0) { return RemoveFirstOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 移除数组指定区域中首个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数length指示比较的元素数
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回移除的元素所在位置.如果未移除任何元素，则返回-1*/
			template<class AnyT, class EqualFunctionType>index_t RemoveFirstOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod);
			/**
			@brief 移除数组指定区域中首个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数length指示比较的元素数
			@return 返回移除的元素所在位置.如果未移除任何元素，则返回-1*/
			template<class AnyT>index_t RemoveFirstOf(AnyT t, index_t startIndex, index_t length) { return RemoveFirstOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 移除数组指定区域中所有与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回总共移除元素的数量*/
			template<class AnyT, class EqualFunctionType>index_t RemoveAllOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod);
			/**
			@brief 移除数组指定区域中所有与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t为指定的要移除的值
			@param [传入,可选]参数startIndex指示开始进行比较的位置，默认是0
			@return 返回总共移除元素的数量*/
			template<class AnyT>index_t RemoveAllOf(AnyT t, index_t startIndex = 0) { return RemoveAllOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 移除数组指定区域中所有与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数length指示比较的元素数
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回总共移除元素的数量*/
			template<class AnyT, class EqualFunctionType>index_t RemoveAllOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod);
			/**
			@brief 移除数组指定区域中所有与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数length指示比较的元素数
			@return 返回总共移除元素的数量*/
			template<class AnyT>index_t RemoveAllOf(AnyT t, index_t startIndex, index_t length) { return RemoveAllOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 移除数组指定区域中指定数量的与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数length指示比较的元素数
			@param [传入]参数maxcount限制移除的元素数量
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回总共移除元素的数量*/
			template<class AnyT, class EqualFunctionType>index_t RemoveSomeOf(AnyT t, index_t startIndex, index_t length, index_t maxcount, EqualFunctionType equalMethod);
			/**
			@brief 移除数组指定区域中指定数量的与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数length指示比较的元素数
			@param [传入]参数maxcount限制移除的元素数量
			@return 返回总共移除元素的数量*/
			template<class AnyT>index_t RemoveSomeOf(AnyT t, index_t startIndex, index_t length, index_t maxcount) { return RemoveSomeOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, maxcount, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将数组指定区域中 第一个与指定值相等的元素 替换为 另一个指定的值
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]参数To表示to的原始数据类型
			@param [传入]参数t为指定的要进行替换的值
			@param [传入]参数to表示替换后的值
			@param [传入]参数startIndex表示进行比较的起始位置
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@retun 返回替换的元素位置，未替换任何元素时返回-1*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceFirstOf(AnyT t, To to, index_t startIndex, EqualFunctionType equalMethod);
			/**
			@brief 将数组指定区域中 第一个与指定值相等的元素 替换为 另一个指定的值
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数To表示to的原始数据类型
			@param [传入]参数t为指定的要进行替换的值
			@param [传入]参数to表示替换后的值
			@param [传入,可选]参数startIndex表示进行比较的起始位置，默认是0
			@retun 返回替换的元素位置，未替换任何元素时返回-1*/
			template<class AnyT, class To>index_t ReplaceFirstOf(AnyT t, To to, index_t startIndex = 0) { return ReplaceFirstOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将数组指定区域中 第一个与指定值相等的元素 替换为 另一个指定的值
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]参数To表示to的原始数据类型
			@param [传入]参数t为指定的要进行替换的值
			@param [传入]参数to表示替换后的值
			@param [传入]参数startIndex表示进行比较的起始位置
			@param [传入]参数length表示进行比较的元素数
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@retun 返回替换的元素位置，未替换任何元素时返回-1*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceFirstOf(AnyT t, To to, index_t startIndex, index_t length, EqualFunctionType equalMethod);
			/**
			@brief 将数组指定区域中 第一个与指定值相等的元素 替换为 另一个指定的值
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数To表示to的原始数据类型
			@param [传入]参数t为指定的要进行替换的值
			@param [传入]参数to表示替换后的值
			@param [传入]参数startIndex表示进行比较的起始位置
			@param [传入]参数length表示进行比较的元素数
			@retun 返回替换的元素位置，未替换任何元素时返回-1*/
			template<class AnyT, class To>index_t ReplaceFirstOf(AnyT t, To to, index_t startIndex, index_t length) { return ReplaceFirstOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将数组指定区域中 所有与指定值相等的元素 替换为 另一个指定的值
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]参数To表示to的原始数据类型
			@param [传入]参数t为指定的要进行替换的值
			@param [传入]参数to表示替换后的值
			@param [传入]参数startIndex表示进行比较的起始位置
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@retun 返回总共替换的元素的数量*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceAllOf(AnyT t, To to, index_t startIndex, EqualFunctionType equalMethod);
			/**
			@brief 将数组指定区域中 所有与指定值相等的元素 替换为 另一个指定的值
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数To表示to的原始数据类型
			@param [传入]参数t为指定的要进行替换的值
			@param [传入]参数to表示替换后的值
			@param [传入,可选]参数startIndex表示进行比较的起始位置
			@retun 返回总共替换的元素的数量*/
			template<class AnyT, class To>index_t ReplaceAllOf(AnyT t, To to, index_t startIndex = 0) { return ReplaceAllOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将数组指定区域中 所有与指定值相等的元素 替换为 另一个指定的值
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]参数To表示to的原始数据类型
			@param [传入]参数t为指定的要进行替换的值
			@param [传入]参数to表示替换后的值
			@param [传入]参数startIndex表示进行比较的起始位置
			@param [传入]参数length表示进行比较的元素数
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@retun 返回总共替换的元素的数量*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceAllOf(AnyT t, To to, index_t startIndex, index_t length, EqualFunctionType equalMethod);
			/**
			@brief 将数组指定区域中 所有与指定值相等的元素 替换为 另一个指定的值
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数To表示to的原始数据类型
			@param [传入]参数t为指定的要进行替换的值
			@param [传入]参数to表示替换后的值
			@param [传入]参数startIndex表示进行比较的起始位置
			@param [传入]参数length表示进行比较的元素数
			@retun 返回总共替换的元素的数量*/
			template<class AnyT, class To>index_t ReplaceAllOf(AnyT t, To to, index_t startIndex, index_t length) { return ReplaceAllOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将数组指定区域中 一定数量的与指定值相等的元素 替换为 另一个指定的值
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]参数To表示to的原始数据类型
			@param [传入]参数t为指定的要进行替换的值
			@param [传入]参数to表示替换后的值
			@param [传入]参数startIndex表示进行比较的起始位置
			@param [传入]参数length表示进行比较的元素数
			@param [传入]参数maxCount限制替换元素的最大数量
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@retun 返回总共替换的元素的数量*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceSomeOf(AnyT t, To to, index_t startIndex, index_t length, index_t maxCount, EqualFunctionType equalMethod);
			/**
			@brief 将数组指定区域中 一定数量的与指定值相等的元素 替换为 另一个指定的值
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数To表示to的原始数据类型
			@param [传入]参数t为指定的要进行替换的值
			@param [传入]参数to表示替换后的值
			@param [传入]参数startIndex表示进行比较的起始位置
			@param [传入]参数length表示进行比较的元素数
			@param [传入]参数maxCount限制替换元素的最大数量
			@retun 返回总共替换的元素的数量*/
			template<class AnyT, class To>index_t ReplaceSomeOf(AnyT t, To to, index_t startIndex, index_t length, index_t maxCount) { return ReplaceSomeOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIndex, length, maxCount, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将数组指定区域部分内容随机乱序排列
			@param [传入]参数startIndex表示起始位置
			@param [传入]参数length表示元素数量
			@param [传入]参数rnd表示随机算子*/
			template<class TT>void SortRandom(index_t startIndex, index_t length, TT& rnd);
			/**
			@brief 将数组指定区域部分内容随机乱序排列
			@param [传入]参数startIndex表示起始位置
			@param [传入]参数length表示元素数量*/
			void SortRandom(index_t startIndex, index_t length);
			/**
			@brief 将数组指定区域部分内容随机乱序排列
			@param [传入,可选]参数startIndex表示起始位置，默认是0*/
			void SortRandom(index_t startIndex);
			/**@brief 随机排序,实现ISortable*/
			void SortRandom() { SortRandom(0); }
			/**
			@brief 反转元素顺序*/
			IArray& Reverse();
			/**
			@brief 在该数组的指定区域查找与指定值相等的第一个元素所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex表示区域起始位置
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回匹配元素的位置，如果没有元素与指定值相等，则返回-1*/
			template<class AnyT, class EqualFunctionType>index_t IndexOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod)const;
			/**
			@brief 在该数组的指定区域查找与指定值相等的第一个元素所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入,可选]参数startIndex表示区域起始位置，默认是0
			@return 返回匹配元素的位置，如果没有元素与指定值相等，则返回-1*/
			template<class AnyT>index_t IndexOf(AnyT t, index_t startIndex = 0)const { return IndexOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在该数组的指定区域查找与指定值相等的第一个元素所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的元素数
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回匹配元素的位置，如果没有元素与指定值相等，则返回-1*/
			template<class AnyT, class EqualFunctionType>index_t IndexOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod)const;
			/**
			@brief 在该数组的指定区域查找与指定值相等的第一个元素所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的元素数
			@return 返回匹配元素的位置，如果没有元素与指定值相等，则返回-1*/
			template<class AnyT>index_t IndexOf(AnyT t, index_t startIndex, index_t length)const { return IndexOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在该数组的指定区域查找与指定值相等的最后一个元素所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex表示区域起始位置
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回匹配元素的位置，如果没有元素与指定值相等，则返回-1*/
			template<class AnyT, class EqualFunctionType>index_t LastIndexOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod)const;
			/**
			@brief 在该数组的指定区域查找与指定值相等的最后一个元素所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入,可选]参数startIndex表示区域起始位置，默认是0
			@return 返回匹配元素的位置，如果没有元素与指定值相等，则返回-1*/
			template<class AnyT>index_t LastIndexOf(AnyT t, index_t startIndex = 0)const { return LastIndexOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在该数组的指定区域查找与指定值相等的最后一个元素所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的元素数
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回匹配元素的位置，如果没有元素与指定值相等，则返回-1*/
			template<class AnyT, class EqualFunctionType>index_t LastIndexOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod)const;
			/**
			@brief 在该数组的指定区域查找与指定值相等的最后一个元素所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的元素数
			@return 返回匹配元素的位置，如果没有元素与指定值相等，则返回-1*/
			template<class AnyT>index_t LastIndexOf(AnyT t, index_t startIndex, index_t length)const { return LastIndexOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在该数组的指定区域查找与指定值相等的第一个元素所在位置迭代器
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回匹配元素的位置迭代器，如果没有元素与指定值相等，则返回end()*/
			template<class AnyT, class EqualFunctionType>ArrayIterator< T> Find(AnyT t, index_t startIndex, EqualFunctionType equalMethod)const;
			/**
			@brief 在该数组的指定区域查找与指定值相等的第一个元素所在位置迭代器
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入,可选]参数startIndex指示区域起始位置，默认是0
			@return 返回匹配元素的位置迭代器，如果没有元素与指定值相等，则返回end()*/
			template<class AnyT>ArrayIterator<T> Find(AnyT t, index_t startIndex = 0)const { return Find<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在该数组的指定区域查找与指定值相等的第一个元素所在位置迭代器
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的元素数
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回匹配元素的位置迭代器，如果没有元素与指定值相等，则返回end()*/
			template<class AnyT, class EqualFunctionType>ArrayIterator< T> Find(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod)const;
			/**
			@brief 在该数组的指定区域查找与指定值相等的第一个元素所在位置迭代器
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的元素数
			@return 返回匹配元素的位置迭代器，如果没有元素与指定值相等，则返回end()*/
			template<class AnyT>ArrayIterator< T> Find(AnyT t, index_t startIndex, index_t length)const { return Find<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在该数组的指定区域应用二分法查找与指定值相等的元素的位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数CompareFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex表示区域起始位置
			@param [传入]参数length表示区域的元素数
			@param [传入]参数compare提供数组元素与插入内容进行比较的方法
			@note 使用前提是所有元素都已排序好（升序或降序）*/
			template<class AnyT, class CompareFunctionType>index_t DichotomyIndexOf(AnyT t, index_t startIndex, index_t length, CompareFunctionType compareMethod)const;
			/**
			@brief 在该数组的指定区域应用二分法查找与指定值相等的元素的位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex表示区域起始位置
			@param [传入]参数length表示区域的元素数
			@note 使用前提是所有元素都已排序好（升序或降序）*/
			template<class AnyT>index_t DichotomyIndexOf(AnyT t, index_t startIndex, index_t length)const { return DichotomyIndexOf<AnyT, typename CompareMethodObject<T&, AnyT>::T>(t, startIndex, length, CompareMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在该数组的指定区域中统计与指定值相等的元素的数量
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入,可选]参数startIndex指示区域起始位置
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回与指定值相等的元素的数量*/
			template<class AnyT, class EqualFunctionType>index_t CountOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod)const;
			/**
			@brief 在该数组的指定区域中统计与指定值相等的元素的数量
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入,可选]参数startIndex指示区域起始位置，默认是0
			@return 返回与指定值相等的元素的数量*/
			template<class AnyT>index_t CountOf(AnyT t, index_t startIndex = 0)const { return CountOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在该数组的指定区域中统计与指定值相等的元素的数量
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的元素数
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回与指定值相等的元素的数量*/
			template<class AnyT, class EqualFunctionType>index_t CountOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod)const;
			/**
			@brief 在该数组的指定区域中统计与指定值相等的元素的数量
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的元素数
			@return 返回与指定值相等的元素的数量*/
			template<class AnyT>index_t CountOf(AnyT t, index_t startIndex, index_t length)const { return CountOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@biref 获取最后一个元素的引用*/
			T& LastElement();
			/**
			@biref 获取最后一个元素的引用*/
			const T& LastElement()const;
			/**
			@biref 获取第一个元素的引用*/
			T& FirstElement();
			/**
			@biref 获取第一个元素的引用*/
			const T& FirstElement()const;
		};

		template<class T>struct PArray :public PArrays
		{
		public:
			typedef IArray<T> vArray;
			typedef ArrayIterator< T> iterator;
			typedef ArrayIterator< T const> const_iterator;
			typedef ReverseArrayIterator< T> reverse_iterator;
			typedef ReverseArrayIterator< T const> const_reverse_iterator;
			typedef T value_type;

			static void AddTypeInfo();
			/**
			@breif 将迭代器beg到end之间的数据赋值给该数组，支持正向和反向迭代器
			@param [模板,可选]AnyT指定迭代器类型
			@param [传入]参数beg为起始位置迭代器
			@param [传入]参数end为终止位置迭代器
			@循环迭代器将被解释为单环*/
			template<class AnyT>void assign(AnyT const& beg, AnyT const&end) { AnyT b = beg; *this = new vArray(); while (b != end) { GetPtr()->Append(*b++); if (b == beg)break; } }
			/**
			@brief 将该数组改变为指定元素数和指定元素值的数组
			@param [传入]参数len表示指定的元素数
			@param [传入]参数val表示指定的元素值*/
			void assign(index_t len, T const&val) { *this = new vArray(len, val); }
			/**
			@brief 获取指定下标的元素的引用
			@param [传入]参数index表示指定的下标
			@return 返回指定下标的元素引用
			@note 该函数会作越界检查*/
			T const&  at(index_t index)const { return Ptr()->at(index); }
			/**
			@brief 获取指定下标的元素的引用
			@param [传入]参数index表示指定的下标
			@return 返回指定下标的元素引用
			@note 该函数会作越界检查*/
			T& at(index_t index) { return Ptr()->at(index); }
			/**
			@brief 获取指定下标的元素的引用
			@param [传入]参数index表示指定的下标
			@return 返回指定下标的元素引用
			@note 该函数会作越界检查*/
			T const&  operator[](index_t index)const { return Ptr()->at(index); }
			/**
			@brief 获取指定下标的元素的引用
			@param [传入]参数index表示指定的下标
			@return 返回指定下标的元素引用
			@note 该函数会作越界检查*/
			T& operator[](index_t index) { return Ptr()->at(index); }
			/**
			@brief 获取最后一个元素的引用
			@该函数不作越界检查*/
			T const& back()const { return Ptr()->back(); }
			/**
			@brief 获取最后一个元素的引用
			@该函数不作越界检查*/
			T& back() { return Ptr()->back(); }
			/**
			@brief 迭代器，位置定位到第一个元素*/
			ArrayIterator< T> begin() { return Ptr()->begin(); }
			/**
			@brief 迭代器，位置定位到第一个元素*/
			ArrayIterator< const T> begin()const { return Ptr()->begin(); }
			/**
			@brief 清理数组*/
			void clear() { Resize(0); }
			/**
			@brief 获取一个bool值以指示该数组是否为空
			@return 当该数组为空数组时，返回true，否则返回false*/
			bool empty()const { return GetLength() == 0; }
			/**
			@brief 迭代器，位置定位到末尾*/
			iterator end() { return Ptr()->end(); }
			/**
			@brief 迭代器，位置定位到末尾*/
			const_iterator end()const { return Ptr()->end(); }

			//读写属性默认的最大预留未使用空间数量（引用Array::MaxUnusedLengthDefault）
			static index_t& MaxUnusedLengthDefault;
			/**
			@brief 获取数组的元素数*/
			inline index_t GetLength()const { return Ptr()->size(); }
			/**
			@brief 获取数组的元素数*sizeof()*/
			inline index_t GetLengthOfBytes()const { return Ptr()->size()*sizeof(T); }
			/**
			@brief 获取数组的元素数（同GetLength）*/
			inline index_t size()const { return Ptr()->size(); }
			/**
			@brief 获取最大预留未使用元素数量*/
			inline index_t GetMaxUnusedLength()const { return Ptr()->MaxUnusedLength; }
			/**
			@brief 设置最大预留未使用元素数量*/
			inline void SetMaxUnusedLength(index_t count) { Ptr()->MaxUnusedLength = count; }
			//通用基类方法
			PMETHODS(PArray, vArray)
			/**
			@brief 传入数组长度，构造一个未初始化的数组
			@param [传入]参数len表示新建数组元素数*/
			PArray(index_t len);
#ifdef _INITIALIZER_LIST_//初始化列表支持
			PArray(std::initializer_list<T> const& lst) :PArrays(new LK::Collection::Array<T>(lst)) {}
#endif
			/**
			@brief 传入数组元素，并使用一个参考元素来初始化所有元素
			@param [传入]参数len表示数组元素数
			@param [传入]参数t为参考元素*/
			PArray(index_t len, const T&t);
			/**
			@brief 使用迭代器构造*/
			template<class IT>PArray(const IT&first, const IT&end);
			/**
			@brief 传入元素数和指针来复制构造数组
			@param [传入]参数len用以指定元素数
			@param [传入]参数p指向存放空间*/
			PArray(index_t len, T* p);
			/**
			@brief 直接转换成指针形式*/
			operator const T*const ()const { return *Ptr(); }
			/**
			@brief 转换成指针形式*/
			operator T*const () { return *Ptr(); }
#if _VC >1800
			/**
			@brief 直接转换成指针形式*/
			template<class LT>inline explicit operator const LT*const ()const { return (const LT*)(const T*const)*this; }
			/**
			@brief 转换成指针形式*/
			template<class LT>inline explicit operator LT*const () { return (LT*)(T*const)*this; }
#endif
			/**
			@brief 迭代器，位置定位到最后一个元素*/
			ReverseArrayIterator< T> rbegin() { return Ptr()->rbegin(); }
			/**
			@brief 迭代器，位置定位到最后一个元素*/
			ReverseArrayIterator< const T> rbegin()const { return Ptr()->rbegin(); }
			/**
			@brief 迭代器，位置定位到起始*/
			ReverseArrayIterator< T> rend() { return Ptr()->rend(); }
			/**
			@brief 迭代器，位置定位到起始*/
			ReverseArrayIterator< const T> rend()const { return Ptr()->rend(); }
			/**
			@brief 获取该数组的一部分（子数组）
			@param [传入]参数startIndex表示起始位置
			@param [传入]参数len表示元素数*/
			PArray SubArray(index_t startIndex, index_t len)const;
			/**
			@brief 从任意类型数据数组source复制所有元素形成T作为元素的数组
			@param [模板,可选]参数AnyT为源数组的元素类型
			@param [传入]参数source表示源数组
			@return 返回元素数据类型为T的数组
			@note 源数组与返回数组的元素将一一对应*/
			template<class AnyT>static PArray<T> CopyFrom(const PArray<AnyT>&source);
			/**
			@brief 从任意类型数据数组source的startIndex索引对应的元素起复制到数组结尾，用以形成元素类型为T的数组
			@param [模板,可选]参数AnyT为源数组的元素类型
			@param [传入]参数source表示源数组
			@param [传入]参数startIndex表示源数组起始复制位置
			@return 返回元素数据类型为T的数组
			@note 源数组与返回数组的元素将一一对应*/
			template<class AnyT>static PArray<T> CopyFrom(const PArray<AnyT>&source, index_t startIndex);
			/**
			@brief 从任意类型数据数组source的startIndex索引对应的元素起复制len个元素，用以形成元素类型为T的数组
			@param [模板,可选]参数AnyT为源数组的元素类型
			@param [传入]参数source表示源数组
			@param [传入]参数startIndex表示源数组起始复制位置
			@param [传入]参数len表示需要复制的元素数
			@return 返回元素数据类型为T的数组
			@note 源数组与返回数组的元素将一一对应*/
			template<class AnyT>static PArray<T> CopyFrom(const PArray<AnyT>&source, index_t startIndex, index_t len);
			/**
			@brief 从任意类型数据数组pdata按字节复制所有内容形成数组
			@param [模板,可选]参数AnyT为源数组的元素类型
			@param [传入]参数source表示源数组
			@return 返回元素数据类型为T的数组
			@note 本函数将直接执行内存复制操作
			@note 如果sizeof(AnyT)不能整除sizeof(T)，那么返回的数组的最后一个元素可能会未完全初始化*/
			template<class AnyT>static PArray<T> CopyFromByBytes(const PArray<AnyT>&source);
			/**
			@brief 从任意类型数据数组pdata按字节复制所有内容形成数组
			@param [模板,可选]参数AnyT为源数组的元素类型
			@param [传入]参数source表示源数组
			@param [传入]参数startByte表示源数组起始复制字节位置
			@return 返回元素数据类型为T的数组
			@note 本函数将直接执行内存复制操作
			@note 如果sizeof(AnyT)不能整除sizeof(T)，那么返回的数组的最后一个元素可能会未完全初始化*/
			template<class AnyT>static PArray<T> CopyFromByBytes(const PArray<AnyT>&source, index_t startByte);
			/**
			@brief 从任意类型数据数组pdata按字节复制所有内容形成数组
			@param [模板,可选]参数AnyT为源数组的元素类型
			@param [传入]参数source表示源数组
			@param [传入]参数startByte表示源数组起始复制字节位置
			@param [传入]参数length表示复制字节数
			@return 返回元素数据类型为T的数组
			@note 本函数将直接执行内存复制操作
			@note 如果sizeof(AnyT)*length不能整除sizeof(T)，那么返回的数组的最后一个元素可能会未完全初始化*/
			template<class AnyT>static PArray<T> CopyFromByBytes(const PArray<AnyT>&source, index_t startByte, index_t length);
			/**
			@breif 将该数组的内容复制一部分到另一个数组，返回实际复制的元素数
			@param [模板,可选]参数AnyT表示目标数组的元素类型
			@param [写出]参数pdata表示目标数组
			@param [传入,可选]参数startIndex表示本数组起始复制位置，默认是0
			@param [传入,可选]参数destinationStartIndex表示目标起始写入位置，默认是0
			@return 返回实际写入元素数
			@note 该复制方法将进行逐个元素一一对应的复制*/
			template<class AnyT>index_t CopyTo(PArray<AnyT>& pdata, index_t startIndex = 0, index_t destinationStartIndex = 0)const;
			/**
			@breif 将该数组的内容复制一部分到另一个数组，返回实际复制的元素数
			@param [模板,可选]参数AnyT表示目标数组的元素类型
			@param [写出]参数pdata表示目标数组
			@param [传入]参数startIndex表示本数组起始复制位置
			@param [传入]参数destinationStartIndex表示目标起始写入位置
			@param [传入]参数length表示复制元素数
			@return 返回实际写入元素数
			@note 该复制方法将进行逐个元素一一对应的复制*/
			template<class AnyT>index_t CopyTo(PArray<AnyT>& pdata, index_t startIndex, index_t destinationStartIndex, index_t length)const;
			/**
			@breif 将该数组的内容复制一部分到另一个数组，返回实际复制的字节数
			@param [模板,可选]参数AnyT表示目标数组的元素类型
			@param [写出]参数pdata表示目标数组
			@param [传入,可选]参数startIndex表示本数组起始复制字节位置，默认是0
			@param [传入,可选]参数destinationStartIndex表示目标起始写入字节位置，默认是0
			@return 返回实际复制的字节数
			@note 该复制方法将直接进行内存复制*/
			template<class AnyT>index_t CopyToByBytes(PArray<AnyT>& pdata, index_t startByte = 0, index_t destinationStartByte = 0)const;
			/**
			@breif 将该数组的内容复制一部分到另一个数组，返回实际复制的字节数
			@param [模板,可选]参数AnyT表示目标数组的元素类型
			@param [写出]参数pdata表示目标数组
			@param [传入]参数startIndex表示本数组起始复制字节位置
			@param [传入]参数destinationStartIndex表示目标起始写入字节位置
			@param [传入]参数lengthOfBytes复制字节数
			@return 返回实际复制的字节数
			@note 该复制方法将直接进行内存复制*/
			template<class AnyT>index_t CopyToByBytes(PArray<AnyT>& pdata, index_t startByte, index_t destinationStartByte, index_t lengthOfBytes)const;
			/**
			@brief 将数组中所有元素的值设置为t
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示设置目标值*/
			template<class AnyT>void ResetTo(const AnyT& t) { return Ptr()->ResetTo(t); }
			/**
			@brief 将数组中指定区域的元素的值设置为t
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示设置目标值
			@param [传入]参数startIndex表示设置起始位置
			@param [传入]参数length表示设置元素数量*/
			template<class AnyT>void ResetTo(const AnyT& t, index_t startIndex, index_t length) { Ptr()->ResetTo(t, startIndex, length); }
			/**
			@brief 在数组的某个位置插入元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数startIndex表示插入位置
			@param [传入]参数t表示要插入的内容*/
			template<class AnyT>void Insert(index_t startIndex, const AnyT&t) { Ptr()->Insert(startIndex, t); }
			/**
			@brief 在对象已升序排序的前提下使用二分法进行插入
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数CompareFunctionType表示比较方法类型
			@param [传入]参数t表示要插入的内容
			@param [传入]参数compare提供数组元素与插入内容进行比较的方法
			@return 返回插入的位置*/
			template<class AnyT, class CompareFunctionType>index_t DichotomyInsertAsc(AnyT t, CompareFunctionType compare) { return Ptr()->DichotomyInsertAsc<AnyT, CompareFunctionType>(t, compare); }
			/**
			@brief 在对象已升序排序的前提下使用二分法进行插入
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示要插入的内容
			@return 返回插入的位置*/
			template<class AnyT>index_t DichotomyInsertAsc(AnyT t) { return DichotomyInsertAsc<AnyT, typename CompareMethodObject<T&, AnyT>::T>(t, CompareMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在数组的某个位置插入数组
			@param [模板,可选]参数AnyT表示xArray的元素数据类型
			@param [传入]参数index表示插入位置
			@param [传入]参数xArray表示要插入的内容*/
			template<class AnyT>void InsertArray(index_t index, const PArray<AnyT>&xArray) { Ptr()->InsertArray(index, *xArray.Ptr()); }
			/**
			@brief 在数组的结尾附加元素
			@param [模板,可选]参数AnyT表示t的数据类型
			@param [传入]参数t表示附加的元素
			@note 该操作将使元素数+1*/
			template<class AnyT>void Append(const AnyT&t) { Ptr()->Append(t); }
			/**
			@brief 在数组的结尾附加元素(同Append)
			@param [模板,可选]参数AnyT表示t的数据类型
			@param [传入]参数t表示附加的元素
			@note 该操作将使元素数+1*/
			template<class AnyT>inline void push_back(const AnyT&t) { Append<AnyT>(t); }
			/**
			@brief 在数组的结尾附加数组
			@param [模板,可选]参数AnyT表示t的数据类型
			@param [传入]参数t表示附加的元素
			@note 该操作将使元素数+1*/
			template<class AnyT>void AppendArray(const PArray<AnyT>&xArray) { Ptr()->AppendArray(*xArray.Ptr()); }
			/**
			@brief 移除指定位置以及其之后的元素
			@param [传入]参数startIndex表示指定的位置
			@note 该操作将使元素数变为startIndex
			@note 被移除部分元素被移除后是否立即析构跟type有关系*/
			void Remove(index_t startIndex) { Ptr()->Remove(startIndex); }
			/**
			@brief 移除指定位置的元素
			@param [传入]参数startIndex表示指定的位置
			@note 该操作将使元素数-1*/
			void RemoveAt(index_t index) { Ptr()->RemoveAt(index); }
			/**
			@brief 移除指定区域的元素
			@param [传入]参数startIndex表示指定的起始移除位置
			@param [传入]参数length表示需要移除的元素数量
			@note 被移除部分元素被移除后是否立即析构跟type有关系*/
			void Remove(index_t startIndex, index_t length) { Ptr()->Remove(startIndex, length); }
			/**
			@brief 移除数组指定区域中首个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入,可选]参数startIndex指示开始进行比较的位置
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回移除的元素所在位置.如果未移除任何元素，则返回-1*/
			template<class AnyT, class EqualFunctionType>index_t RemoveFirstOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod) { return Ptr()->RemoveFirstOf<AnyT, EqualFunctionType>(t, startIndex, equalMethod); }
			/**
			@brief 移除数组指定区域中首个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t为指定的要移除的值
			@param [传入,可选]参数startIndex指示开始进行比较的位置，默认为0
			@return 返回移除的元素所在位置.如果未移除任何元素，则返回-1*/
			template<class AnyT>index_t RemoveFirstOf(AnyT t, index_t startIndex = 0) { return RemoveFirstOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 移除数组指定区域中首个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数length指示比较的元素数
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回移除的元素所在位置.如果未移除任何元素，则返回-1*/
			template<class AnyT, class EqualFunctionType>index_t RemoveFirstOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod) { return Ptr()->RemoveFirstOf<AnyT, EqualFunctionType>(t, startIndex, length, equalMethod); }
			/**
			@brief 移除数组指定区域中首个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数length指示比较的元素数
			@return 返回移除的元素所在位置.如果未移除任何元素，则返回-1*/
			template<class AnyT>index_t RemoveFirstOf(AnyT t, index_t startIndex, index_t length) { return RemoveFirstOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 移除数组指定区域中所有与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回总共移除元素的数量*/
			template<class AnyT, class EqualFunctionType>index_t RemoveAllOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod) { return Ptr()->RemoveAllOf<AnyT, EqualFunctionType>(t, startIndex, equalMethod); }
			/**
			@brief 移除数组指定区域中所有与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t为指定的要移除的值
			@param [传入,可选]参数startIndex指示开始进行比较的位置，默认是0
			@return 返回总共移除元素的数量*/
			template<class AnyT>index_t RemoveAllOf(AnyT t, index_t startIndex = 0) { return RemoveAllOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 移除数组指定区域中所有与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数length指示比较的元素数
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回总共移除元素的数量*/
			template<class AnyT, class EqualFunctionType>index_t RemoveAllOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod) { return Ptr()->RemoveAllOf<AnyT, EqualFunctionType>(t, startIndex, length, equalMethod); }
			/**
			@brief 移除数组指定区域中所有与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数length指示比较的元素数
			@return 返回总共移除元素的数量*/
			template<class AnyT>index_t RemoveAllOf(AnyT t, index_t startIndex, index_t length) { return RemoveAllOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 移除数组指定区域中指定数量的与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数length指示比较的元素数
			@param [传入]参数maxCount限制移除的元素数量
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回总共移除元素的数量*/
			template<class AnyT, class EqualFunctionType>index_t RemoveSomeOf(AnyT t, index_t startIndex, index_t length, index_t maxCount, EqualFunctionType equalMethod) { return Ptr()->RemoveSomeOf<AnyT, EqualFunctionType>(t, startIndex, length, maxCount, equalMethod); }
			/**
			@brief 移除数组指定区域中指定数量的与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数length指示比较的元素数
			@param [传入]参数maxcount限制移除的元素数量
			@return 返回总共移除元素的数量*/
			template<class AnyT>index_t RemoveSomeOf(AnyT t, index_t startIndex, index_t length, index_t maxcount) { return RemoveSomeOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, maxcount, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将数组指定区域中 第一个与指定值相等的元素 替换为 另一个指定的值
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]参数To表示to的原始数据类型
			@param [传入]参数t为指定的要进行替换的值
			@param [传入]参数to表示替换后的值
			@param [传入]参数startIndex表示进行比较的起始位置
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@retun 返回替换的元素位置，未替换任何元素时返回-1*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceFirstOf(AnyT t, To to, index_t startIndex, EqualFunctionType equalMethod) { return Ptr()->ReplaceFirstOf<AnyT, EqualFunctionType, To>(t, to, startIndex, equalMethod); }
			/**
			@brief 将数组指定区域中 第一个与指定值相等的元素 替换为 另一个指定的值
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数To表示to的原始数据类型
			@param [传入]参数t为指定的要进行替换的值
			@param [传入]参数to表示替换后的值
			@param [传入,可选]参数startIndex表示进行比较的起始位置，默认是0
			@retun 返回替换的元素位置，未替换任何元素时返回-1*/
			template<class AnyT, class To>index_t ReplaceFirstOf(AnyT t, To to, index_t startIndex = 0) { return ReplaceFirstOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将数组指定区域中 第一个与指定值相等的元素 替换为 另一个指定的值
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]参数To表示to的原始数据类型
			@param [传入]参数t为指定的要进行替换的值
			@param [传入]参数to表示替换后的值
			@param [传入]参数startIndex表示进行比较的起始位置
			@param [传入]参数length表示进行比较的元素数
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@retun 返回替换的元素位置，未替换任何元素时返回-1*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceFirstOf(AnyT t, To to, index_t startIndex, index_t length, EqualFunctionType equalMethod) { return Ptr()->ReplaceFirstOf<AnyT, EqualFunctionType, To>(t, to, startIndex, length, equalMethod); }
			/**
			@brief 将数组指定区域中 第一个与指定值相等的元素 替换为 另一个指定的值
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数To表示to的原始数据类型
			@param [传入]参数t为指定的要进行替换的值
			@param [传入]参数to表示替换后的值
			@param [传入]参数startIndex表示进行比较的起始位置
			@param [传入]参数length表示进行比较的元素数
			@retun 返回替换的元素位置，未替换任何元素时返回-1*/
			template<class AnyT, class To>index_t ReplaceFirstOf(AnyT t, To to, index_t startIndex, index_t length) { return ReplaceFirstOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将数组指定区域中 所有与指定值相等的元素 替换为 另一个指定的值
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]参数To表示to的原始数据类型
			@param [传入]参数t为指定的要进行替换的值
			@param [传入]参数to表示替换后的值
			@param [传入]参数startIndex表示进行比较的起始位置
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@retun 返回总共替换的元素的数量*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceAllOf(AnyT t, To to, index_t startIndex, EqualFunctionType equalMethod) { return Ptr()->ReplaceAllOf<AnyT, EqualFunctionType, To>(t, to, startIndex, equalMethod); }
			/**
			@brief 将数组指定区域中 所有与指定值相等的元素 替换为 另一个指定的值
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数To表示to的原始数据类型
			@param [传入]参数t为指定的要进行替换的值
			@param [传入]参数to表示替换后的值
			@param [传入,可选]参数startIndex表示进行比较的起始位置
			@retun 返回总共替换的元素的数量*/
			template<class AnyT, class To>index_t ReplaceAllOf(AnyT t, To to, index_t startIndex = 0) { return ReplaceAllOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将数组指定区域中 所有与指定值相等的元素 替换为 另一个指定的值
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]参数To表示to的原始数据类型
			@param [传入]参数t为指定的要进行替换的值
			@param [传入]参数to表示替换后的值
			@param [传入]参数startIndex表示进行比较的起始位置
			@param [传入]参数length表示进行比较的元素数
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@retun 返回总共替换的元素的数量*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceAllOf(AnyT t, To to, index_t startIndex, index_t length, EqualFunctionType equalMethod) { return Ptr()->ReplaceAllOf<AnyT, EqualFunctionType, To>(t, to, startIndex, length, equalMethod); }
			/**
			@brief 将数组指定区域中 所有与指定值相等的元素 替换为 另一个指定的值
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数To表示to的原始数据类型
			@param [传入]参数t为指定的要进行替换的值
			@param [传入]参数to表示替换后的值
			@param [传入]参数startIndex表示进行比较的起始位置
			@param [传入]参数length表示进行比较的元素数
			@retun 返回总共替换的元素的数量*/
			template<class AnyT, class To>index_t ReplaceAllOf(AnyT t, To to, index_t startIndex, index_t length) { return ReplaceAllOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将数组指定区域中 一定数量的与指定值相等的元素 替换为 另一个指定的值
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]参数To表示to的原始数据类型
			@param [传入]参数t为指定的要进行替换的值
			@param [传入]参数to表示替换后的值
			@param [传入]参数startIndex表示进行比较的起始位置
			@param [传入]参数length表示进行比较的元素数
			@param [传入]参数maxCount限制替换元素的最大数量
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@retun 返回总共替换的元素的数量*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceSomeOf(AnyT t, To to, index_t startIndex, index_t length, index_t maxCount, EqualFunctionType equalMethod) { return Ptr()->ReplaceSomeOf<AnyT, EqualFunctionType, To>(t, to, startIndex, length, maxCount, equalMethod); }
			/**
			@brief 将数组指定区域中 一定数量的与指定值相等的元素 替换为 另一个指定的值
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数To表示to的原始数据类型
			@param [传入]参数t为指定的要进行替换的值
			@param [传入]参数to表示替换后的值
			@param [传入]参数startIndex表示进行比较的起始位置
			@param [传入]参数length表示进行比较的元素数
			@param [传入]参数maxCount限制替换元素的最大数量
			@retun 返回总共替换的元素的数量*/
			template<class AnyT, class To>index_t ReplaceSomeOf(AnyT t, To to, index_t startIndex, index_t length, index_t maxCount) { return ReplaceSomeOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIndex, length, maxCount, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将数组指定区域部分内容随机乱序排列
			@param [传入]参数startIndex表示起始位置
			@param [传入]参数length表示元素数量
			@param [传入]参数rnd表示随机算子*/
			template<class TT>void SortRandom(index_t startIndex, index_t length, TT& rnd) { Ptr()->SortRandom(startIndex, length, rnd); }
			/**
			@brief 将数组指定区域部分内容随机乱序排列
			@param [传入]参数startIndex表示起始位置
			@param [传入]参数length表示元素数量*/
			void SortRandom(index_t startIndex, index_t length) { Ptr()->SortRandom(startIndex, length); }
			/**
			@brief 将数组指定区域部分内容随机乱序排列
			@param [传入,可选]参数startIndex表示起始位置，默认是0*/
			void SortRandom(index_t startIndex = 0) { Ptr()->SortRandom(startIndex); }
			/**
			@brief 反转元素顺序*/
			PArray& Reverse() { Ptr()->Reverse(); return *this; }
			/**
			@brief 在该数组的指定区域查找与指定值相等的第一个元素所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex表示区域起始位置
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回匹配元素的位置，如果没有元素与指定值相等，则返回-1*/
			template<class AnyT, class EqualFunctionType>index_t IndexOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod)const { return Ptr()->IndexOf<AnyT, EqualFunctionType>(t, startIndex, equalMethod); }
			/**
			@brief 在该数组的指定区域查找与指定值相等的第一个元素所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入,可选]参数startIndex表示区域起始位置，默认是0
			@return 返回匹配元素的位置，如果没有元素与指定值相等，则返回-1*/
			template<class AnyT>index_t IndexOf(AnyT t, index_t startIndex = 0)const { return IndexOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在该数组的指定区域查找与指定值相等的第一个元素所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的元素数
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回匹配元素的位置，如果没有元素与指定值相等，则返回-1*/
			template<class AnyT, class EqualFunctionType>index_t IndexOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod)const { return Ptr()->IndexOf<AnyT, EqualFunctionType>(t, startIndex, length, equalMethod); }
			/**
			@brief 在该数组的指定区域查找与指定值相等的第一个元素所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的元素数
			@return 返回匹配元素的位置，如果没有元素与指定值相等，则返回-1*/
			template<class AnyT>index_t IndexOf(AnyT t, index_t startIndex, index_t length)const { return IndexOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在该数组的指定区域查找与指定值相等的最后一个元素所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex表示区域起始位置
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回匹配元素的位置，如果没有元素与指定值相等，则返回-1*/
			template<class AnyT, class EqualFunctionType>index_t LastIndexOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod)const { return Ptr()->LastIndexOf<AnyT, EqualFunctionType>(t, startIndex, equalMethod); }
			/**
			@brief 在该数组的指定区域查找与指定值相等的最后一个元素所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入,可选]参数startIndex表示区域起始位置，默认是0
			@return 返回匹配元素的位置，如果没有元素与指定值相等，则返回-1*/
			template<class AnyT>index_t LastIndexOf(AnyT t, index_t startIndex = 0)const { return LastIndexOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在该数组的指定区域查找与指定值相等的最后一个元素所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的元素数
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回匹配元素的位置，如果没有元素与指定值相等，则返回-1*/
			template<class AnyT, class EqualFunctionType>index_t LastIndexOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod)const { return Ptr()->LastIndexOf<AnyT, EqualFunctionType>(t, startIndex, length, equalMethod); }
			/**
			@brief 在该数组的指定区域查找与指定值相等的最后一个元素所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的元素数
			@return 返回匹配元素的位置，如果没有元素与指定值相等，则返回-1*/
			template<class AnyT>index_t LastIndexOf(AnyT t, index_t startIndex, index_t length)const { return LastIndexOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在该数组的指定区域查找与指定值相等的第一个元素所在位置迭代器
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回匹配元素的位置迭代器，如果没有元素与指定值相等，则返回end()*/
			template<class AnyT, class EqualFunctionType>ArrayIterator< T> Find(AnyT t, index_t startIndex, EqualFunctionType equalMethod)const { return Ptr()->Find<AnyT, EqualFunctionType>(t, startIndex, equalMethod); }
			/**
			@brief 在该数组的指定区域查找与指定值相等的第一个元素所在位置迭代器
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入,可选]参数startIndex指示区域起始位置，默认是0
			@return 返回匹配元素的位置迭代器，如果没有元素与指定值相等，则返回end()*/
			template<class AnyT>ArrayIterator< T> Find(AnyT t, index_t startIndex = 0)const { return Find<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在该数组的指定区域查找与指定值相等的第一个元素所在位置迭代器
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的元素数
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回匹配元素的位置迭代器，如果没有元素与指定值相等，则返回end()*/
			template<class AnyT, class EqualFunctionType>ArrayIterator< T> Find(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod)const { return Ptr()->Find<AnyT, EqualFunctionType>(t, startIndex, length, equalMethod); }
			/**
			@brief 在该数组的指定区域查找与指定值相等的第一个元素所在位置迭代器
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的元素数
			@return 返回匹配元素的位置迭代器，如果没有元素与指定值相等，则返回end()*/
			template<class AnyT>ArrayIterator< T> Find(AnyT t, index_t startIndex, index_t length)const { return Find<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在该数组的指定区域应用二分法查找与指定值相等的元素的位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数CompareFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex表示区域起始位置
			@param [传入]参数length表示区域的元素数
			@param [传入]参数compare提供数组元素与插入内容进行比较的方法
			@note 使用前提是所有元素都已排序好（升序或降序）*/
			template<class AnyT, class CompareFunctionType>index_t DichotomyIndexOf(AnyT t, index_t startIndex, index_t length, CompareFunctionType compareMethod)const { return Ptr()->DichotomyIndexOf<AnyT, CompareFunctionType>(t, startIndex, length, compareMethod); }
			/**
			@brief 在该数组的指定区域应用二分法查找与指定值相等的元素的位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数CompareFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex表示区域起始位置
			@param [传入]参数compare提供数组元素与插入内容进行比较的方法
			@note 使用前提是所有元素都已排序好（升序或降序）*/
			template<class AnyT, class CompareFunctionType>index_t DichotomyIndexOf(AnyT t, index_t startIndex, CompareFunctionType compareMethod)const { return Ptr()->DichotomyIndexOf<AnyT, CompareFunctionType>(t, startIndex, GetLength() - startIndex, compareMethod); }
			/**
			@brief 在该数组的指定区域应用二分法查找与指定值相等的元素的位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数CompareFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数compare提供数组元素与插入内容进行比较的方法
			@note 使用前提是所有元素都已排序好（升序或降序）*/
			template<class AnyT, class CompareFunctionType>index_t DichotomyIndexOf(AnyT t, CompareFunctionType compareMethod)const { return Ptr()->DichotomyIndexOf<AnyT, CompareFunctionType>(t, 0, GetLength(), compareMethod); }
			/**
			@brief 在该数组的指定区域应用二分法查找与指定值相等的元素的位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex表示区域起始位置
			@param [传入]参数length表示区域的元素数
			@note 使用前提是所有元素都已排序好（升序或降序）*/
			template<class AnyT>index_t DichotomyIndexOf(AnyT t, index_t startIndex, index_t length)const { return DichotomyIndexOf<AnyT, typename CompareMethodObject<T&, AnyT>::T>(t, startIndex, length, CompareMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在该数组的指定区域应用二分法查找与指定值相等的元素的位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入,可选]参数startIndex表示区域起始位置，默认是0
			@note 使用前提是所有元素都已排序好（升序或降序）*/
			template<class AnyT>index_t DichotomyIndexOf(AnyT t, index_t startIndex = 0)const { return DichotomyIndexOf<AnyT, typename CompareMethodObject<T&, AnyT>::T>(t, startIndex, GetLength() - startIndex, CompareMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在该数组的指定区域中统计与指定值相等的元素的数量
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入,可选]参数startIndex指示区域起始位置
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回与指定值相等的元素的数量*/
			template<class AnyT, class EqualFunctionType>index_t CountOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod)const { return Ptr()->CountOf<AnyT, EqualFunctionType>(t, startIndex, equalMethod); }
			/**
			@brief 在该数组的指定区域中统计与指定值相等的元素的数量
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入,可选]参数startIndex指示区域起始位置，默认是0
			@return 返回与指定值相等的元素的数量*/
			template<class AnyT>index_t CountOf(AnyT t, index_t startIndex = 0)const { return CountOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在该数组的指定区域中统计与指定值相等的元素的数量
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的元素数
			@param [传入]参数equalMethod提供比较数组元素和t相等的方法
			@return 返回与指定值相等的元素的数量*/
			template<class AnyT, class EqualFunctionType>index_t CountOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod)const { return Ptr()->CountOf<AnyT, EqualFunctionType>(t, startIndex, length, equalMethod); }
			/**
			@brief 在该数组的指定区域中统计与指定值相等的元素的数量
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的元素数
			@return 返回与指定值相等的元素的数量*/
			template<class AnyT>index_t CountOf(AnyT t, index_t startIndex, index_t length)const { return CountOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@biref 获取最后一个元素的引用*/
			T& LastElement() { return Ptr()->LastElement(); }
			/**
			@biref 获取最后一个元素的引用*/
			const T& LastElement()const { return Ptr()->LastElement(); }
			/**
			@biref 获取第一个元素的引用*/
			T& FirstElement() { return Ptr()->FirstElement(); }
			/**
			@biref 获取第一个元素的引用*/
			const T& FirstElement()const { return Ptr()->FirstElement(); }
			/**
			@brief 获取数组数据保存方式
			@note 方式有：
			@note 1.普通：Normal。该方式下内存通过new申请，通过delete释放。该方式下很可能无法实现移除元素的立即析构
			@note 2.引用：Reference。该方式下认为内存是读写引用，不能进行释放操作，因此也无法进行大小调整。
			@note 3.自构造：InnerConstruct。该方式下内存分配由内部管理，可实现移除元素的立即析构。*/
			size_t GetArrayType()const { return Ptr()->GetArrayType(); }
			/**
			@brief 获取数组当前最大容量
			@note 当数组元素数不大于最大容量，而且两者之差不大于MaxUnusedLength时，对象存储区域将不会进行内存的重新调整*/
			index_t GetMaxSize()const { return Ptr()->GetMaxSize(); }
		};

		template<class T>inline IArray<T>& IArray<T>::Reverse()
		{
			if (size() > 0)
				for (T* p = getdata(), *pt = getdata() + size() - 1; p < pt; ++p, --pt)
				Swap(*p, *pt);
			return *this;
		}
		template<class T>template<class AnyT>index_t IArray<T>::CopyTo(IArray<AnyT>& destination, index_t sourceIndex, index_t destinationIndex)const
		{
			if (sourceIndex < 0 || destinationIndex < 0)throw PInvalidArgumentException(L"索引不得<0");//参数无效
			if (sourceIndex > size() || destinationIndex > destination.size())throw PIndexOutOfRangeException();
			index_t length = (size() - sourceIndex > destination.size() - destinationIndex) ? destination.size() - destinationIndex : size() - sourceIndex;
			T* p = *this + sourceIndex;
			T* pEnd = p + length;
			AnyT* pd = destination + destinationIndex;
			while (p < pEnd) { *pd = *p; ++p; ++pd; }//强制转换
			return length;
		}
		template<class T>template<class AnyT>index_t IArray<T>::CopyTo(IArray<AnyT>& destination, index_t sourceIndex, index_t destinationIndex, index_t length)const
		{
			if (sourceIndex < 0 || destinationIndex < 0 || length < 0)throw PInvalidArgumentException(L"索引不得<0");//参数无效
			if (sourceIndex + length > size() || destinationIndex + length > destination.size())throw PIndexOutOfRangeException();
			T* p = *this + sourceIndex;
			T* pEnd = p + length;
			AnyT* pd = destination + destinationIndex;
			while (p < pEnd) { *pd = *p; ++p; ++pd; }//强制转换
			return length;
		}
		template<class T>template<class AnyT>index_t IArray<T>::CopyToByBytes(IArray<AnyT>& dest, index_t sourceByte, index_t destinationByte)const
		{
			if (sourceByte < 0 || destinationByte < 0)throw PInvalidArgumentException();//参数无效
			if (sourceByte > GetLengthOfBytes() || destinationByte > dest.GetLengthOfBytes())throw PIndexOutOfRangeException();
			index_t lengthOfByte = (GetLengthOfBytes() - sourceByte > dest.GetLengthOfBytes() - destinationByte) ? dest.GetLengthOfBytes() - destinationByte : GetLengthOfBytes() - sourceByte;
			Memory::Copy(((unsigned char*)(AnyT*)dest) + destinationByte, ((unsigned char*)getdata()) + sourceByte, lengthOfByte);
			return lengthOfByte;
		}
		template<class T>template<class AnyT>index_t IArray<T>::CopyToByBytes(IArray<AnyT>& dest, index_t sourceByte, index_t destinationByte, index_t lengthOfByte)const
		{
			if (sourceByte < 0 || destinationByte < 0 || lengthOfByte < 0)throw PInvalidArgumentException();//参数无效
			if (sourceByte + lengthOfByte > GetLengthOfBytes() || lengthOfByte + destinationByte > dest.GetLengthOfBytes())throw PIndexOutOfRangeException();
			Memory::Copy(((unsigned char*)(AnyT*)dest) + destinationByte, ((unsigned char*)getdata()) + sourceByte, lengthOfByte);
			return lengthOfByte;
		}
		template<class T> T* operator+(IArray<T>& xArray, index_t mov)
		{
			return (T*)xArray + mov;
		}
		template<class T> const T* operator+(const IArray<T>& xArray, index_t mov)
		{
			return (const T*)xArray + mov;
		}
		template<class T> T* operator-(IArray<T>& xArray, index_t mov)
		{
			return (T*)xArray - mov;
		}
		template<class T> const T* operator-(const IArray<T>& xArray, index_t mov)
		{
			return (const T*)xArray - mov;
		}
		template<class T> T* operator+(index_t mov, IArray<T>& xArray)
		{
			return (T*)xArray + mov;
		}
		template<class T> const T* operator+(index_t mov, const IArray<T>& xArray)
		{
			return (const T*)xArray + mov;
		}
		template<class T> bool operator==(const IArray<T>& x1, const IArray<T>& x2)
		{
			if (x1.size() != x2.size())return false;
			const T* p1 = x1; const T*pe1 = p1 + x1.size();
			const T* p2 = x2;
			while (p1 != pe1)if (*p1++ != *p2++)return false;
			return true;
		}
		template<class T> bool operator!=(const IArray<T>& x1, const IArray<T>& x2)
		{
			if (x1.size() != x2.size())return true;
			const T* p1 = x1; const T*pe1 = p1 + x1.size();
			const T* p2 = x2;
			while (p1 != pe1)if (*p1++ != *p2++)return true;
			return false;
		}
		template<class T> bool operator>=(const IArray<T>& x1, const IArray<T>& x2)
		{
			const T* p1 = x1; const T*pe1 = p1 + x1.size();
			const T* p2 = x2; const T*pe2 = p2 + x2.size();
			while (p1 != pe1&& pe2 != pe2) { if (*p1 != *p2)break; ++p1; ++p2; }
			if (p1 == pe1)return p2 == pe2;
			if (p2 == pe2)return true;
			return *p1 >= *p2;
		}
		template<class T> bool operator<=(const IArray<T>& x1, const IArray<T>& x2)
		{
			const T* p1 = x1; const T*pe1 = p1 + x1.size();
			const T* p2 = x2; const T*pe2 = p2 + x2.size();
			while (p1 != pe1&& pe2 != pe2) { if (*p1 != *p2)break; ++p1; ++p2; }
			if (p1 == pe1)return p2 != pe2;
			if (p2 == pe2)return false;
			return *p1 <= *p2;
		}
		template<class T> bool operator>(const IArray<T>& x1, const IArray<T>& x2)
		{
			const T* p1 = x1; const T*pe1 = p1 + x1.size();
			const T* p2 = x2; const T*pe2 = p2 + x2.size();
			while (p1 != pe1&& pe2 != pe2) { if (*p1 != *p2)break; ++p1; ++p2; }
			if (p1 == pe1)return false;
			if (p2 == pe2)return true;
			return *p1 > *p2;
		}
		template<class T> bool operator<(const IArray<T>& x1, const IArray<T>& x2)
		{
			const T* p1 = x1; const T*pe1 = p1 + x1.size();
			const T* p2 = x2; const T*pe2 = p2 + x2.size();
			while (p1 != pe1&& pe2 != pe2) { if (*p1 != *p2)break; ++p1; ++p2; }
			if (p1 == pe1)return true;
			if (p2 == pe2)return false;
			return *p1 < *p2;
		}
		template<class T>template<class AnyT>void  IArray<T>::ResetTo(const AnyT& t)
		{
			T*p(getdata());
			T*end(getdata() + size());
			while (p != end)*p++ = t;
		}
		template<class T>template<class AnyT>void  IArray<T>::ResetTo(const AnyT& t, index_t index, index_t length)
		{
			if (CheckIndex(index, length))return;
			T*p(getdata() + index);
			T*end(getdata() + size());
			while (p < end)*p++ = t;
		}
		template<class T>template<class AnyT>void IArray<T>::Insert(index_t index, const AnyT&t)
		{
			CheckIndex(index);
			Resize(size() + 1);
			T*p = getdata();
			for (index_t i = size() - 1; i != index; --i)
#ifdef SUPPORT_RIGHT_VALUE_REFERENCE
				p[i] = (T&&)p[i - 1];
#else
				p[i] = p[i - 1];
#endif
			p[index] = t;
		}
		template<class T>template<class AnyT>void IArray<T>::InsertArray(index_t index, const IArray<AnyT>&xArray)
		{
			if (xArray.size() == 0)return;
			Resize(size() + xArray.size());
			T*p = getdata();
			const AnyT*pp = xArray.getdata();
			for (index_t i = size() - 1; i != xArray.size() - 1; --i)
#ifdef SUPPORT_RIGHT_VALUE_REFERENCE
				p[i] = (T&&)p[i - xArray.size()];
#else
				p[i] = p[i - xArray.size()];
#endif
			for (index_t i = 0; i != xArray.size(); ++i)
				p[i] = pp[i];
		}
		/**结尾附加*/
		template<class T>template<class AnyT>void IArray<T>::Append(const AnyT&t)
		{
			Resize(size() + 1);
			LastElement() = t;
		}
		template<class T>template<class AnyT>void IArray<T>::AppendArray(const IArray<AnyT>&xArray)
		{
			if (xArray.size() == 0)return;
			index_t lena = size();
			index_t lenb = xArray.size();
			Resize(lena + lenb);
			T*p = getdata() + lena;
			const AnyT*pp = xArray.getdata();
			for (index_t i = 0; i < lenb; ++i)
				*p++ = *pp++;
		}
		template<class T>void  IArray<T>::Remove(index_t startIndex)
		{
			Resize(startIndex);
		}
		template<class T>void IArray<T>::RemoveAt(index_t index)
		{
			if (CheckIndex(index))return;
			T*p = getdata();
			for (index_t i = index + 1; i != size(); ++i)
#ifdef SUPPORT_RIGHT_VALUE_REFERENCE
				p[i - 1] = (T&&)p[i];
#else
				p[i - 1] = p[i];
#endif
			Resize(size() - 1);
		}
		template<class T>void  IArray<T>::Remove(index_t startIndex, index_t len)
		{
			if (CheckIndex(startIndex, len))return;
			if (startIndex + len == size())return Remove(startIndex);
			if (CheckIndex(startIndex))return;
			T*p = getdata();
			for (index_t i = startIndex + len; i != size(); ++i)
#ifdef SUPPORT_RIGHT_VALUE_REFERENCE
				p[i - len] = (T&&)p[i];
#else
				p[i - len] = p[i];
#endif
			Resize(size() - len);
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t IArray<T>::RemoveFirstOf(AnyT t, index_t startIndex, EqualFunctionType equal)
		{
			if (CheckIndex(startIndex))return -1;
			T*p = getdata();
			while (startIndex < size() && !equal(p[startIndex], t))++startIndex;
			if (startIndex == size())return-1;
			RemoveAt(startIndex);
			return startIndex;
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t IArray<T>::RemoveFirstOf(AnyT t, index_t startIndex, index_t len, EqualFunctionType equal)
		{
			if (CheckIndex(startIndex, len))return -1;
			T*p = getdata();
			index_t i = startIndex;
			while (i < startIndex + len&&!equal(p[i], t))++i;
			if (i == startIndex + len)return-1;
			RemoveAt(i);
			return i;
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t IArray<T>::RemoveAllOf(AnyT t, index_t startIndex, EqualFunctionType equal)
		{
			if (CheckIndex(startIndex))return 0;
			T*end(getdata() + size());
			T*pt(getdata() + startIndex);
			T*pc(pt);
			while (pt != end)
			{
				if (equal(*pt, t)) { ++pt; }
#ifdef SUPPORT_RIGHT_VALUE_REFERENCE
				else if (pc != pt)*pc++ = (T&&)*pt++;
#else
				else if (pc != pt)*pc++ = *pt++;
#endif
			}
			Resize(size() - index_t(pt - pc));
			return index_t(pt - pc);
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t IArray<T>::RemoveAllOf(AnyT t, index_t startIndex, index_t len, EqualFunctionType equal)
		{
			if (CheckIndex(startIndex, len))return 0;
			T*end(getdata() + size());//数据终止点
			T*pt(getdata() + startIndex);//起始查找点
			T*pe(pt + len);//查找截断点
			T*pc(pt);//复制数据起始点
			while (pt != end)
			{
				if (pt < pe && equal(*pt, t)) { ++pt; }
#ifdef SUPPORT_RIGHT_VALUE_REFERENCE
				else if (pc != pt)*pc++ = (T&&)*pt++;
#else
				else if (pc != pt)*pc++ = *pt++;
#endif
			}
			Resize(size() - index_t(pt - pc));
			return index_t(pt - pc);
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t IArray<T>::RemoveSomeOf(AnyT t, index_t startIndex, index_t len, index_t count, EqualFunctionType equal)
		{
			if (count < 0)throw PInvalidArgumentException();
			if (CheckIndex(startIndex, len) || count == 0)return end();
			T*end(getdata() + size());//数据终止点
			T*pt(getdata() + startIndex);//起始查找点
			T*pe(pt + len);//查找截断点
			T*pc(pt);//复制数据起始点
			while (pt != end)
			{
				if (pt < pe &&count>0 && equal(*pt, t)) { ++pt; --count; }
#ifdef SUPPORT_RIGHT_VALUE_REFERENCE
				else if (pc != pt)*pc++ = (T&&)*pt++;
#else
				else if (pc != pt)*pc++ = *pt++;
#endif
			}
			Resize(size() - index_t(pt - pc));
			return index_t(pt - pc);
		}
		template<class T>template<class AnyT, class EqualFunctionType, class To>index_t IArray<T>::ReplaceFirstOf(AnyT  t, To to, index_t startIndex, EqualFunctionType equal)
		{
			if (CheckIndex(startIndex))return -1;
			T*end(getdata() + size());
			T*pt(getdata() + startIndex);
			while (pt != end && !(equal(*pt, t)))++pt;//查找相同元素的位置
			if (pt == end)return -1;//没找到需要移除的元素
			*pt = to;
			return index_t(pt - getdata());
		}
		template<class T>template<class AnyT, class EqualFunctionType, class To>index_t IArray<T>::ReplaceFirstOf(AnyT  t, To to, index_t startIndex, index_t len, EqualFunctionType equal)
		{
			if (CheckIndex(startIndex, len))return -1;
			T*pt(getdata() + startIndex);
			T*end(pt + len);
			while (pt != end && !equal(*pt, t))++pt;//查找相同元素的位置
			if (pt == end)return -1;//没找到需要移除的元素
			*pt = to;
			return index_t(pt - getdata());
		}
		template<class T>template<class AnyT, class EqualFunctionType, class To>index_t IArray<T>::ReplaceAllOf(AnyT t, To to, index_t startIndex, EqualFunctionType equal)
		{
			if (CheckIndex(startIndex))return 0;
			index_t c = 0;
			T*end(getdata() + size());
			T*pt(getdata() + startIndex);
			while (pt != end)
			{
				if (*pt == t)
				{
					c++;
					*pt = to;
				}
				++pt;
			}
			return c;
		}
		template<class T>template<class AnyT, class EqualFunctionType, class To>index_t IArray<T>::ReplaceAllOf(AnyT t, To to, index_t startIndex, index_t len, EqualFunctionType equal)
		{
			if (CheckIndex(startIndex, len))return 0;
			index_t c = 0;
			T*pt(getdata() + startIndex);
			T*end(pt + len);
			while (pt != end)
			{
				if (*pt == t)
				{
					c++;
					*pt = to;
				}
				++pt;
			}
			return c;
		}
		template<class T>template<class AnyT, class EqualFunctionType, class To>index_t IArray<T>::ReplaceSomeOf(AnyT t, To to, index_t startIndex, index_t length, index_t count, EqualFunctionType equal)
		{
			if (count < 0)throw PInvalidArgumentException();
			if (CheckIndex(startIndex, length) || count == 0)return 0;
			index_t c = 0;
			T*pt(getdata() + startIndex);
			T*end(pt + length);
			while (pt != end)
			{
				if (*pt == t)
				{
					c++
						*pt = to;
					if (--count == 0)break;
				}
				++pt;
			}
			return c;
		}
		template<class T>void IArray<T>::SortRandom(index_t startIndex, index_t len)
		{
			return SortRandom(startIndex, len, PRandom::GetDefaultRef());
		}
		template<class T>template<class TT>void IArray<T>::SortRandom(index_t startIndex, index_t length, TT& rnd)
		{
			if (startIndex < 0 || length < 0)throw PInvalidArgumentException();
			if (startIndex + length > size())throw PIndexOutOfRangeException();
			T*p = getdata();
			for (index_t i = 1; i < length; ++i)
			{
				Object::Swap(*(p + i), *(p + size_t(rnd) % (i + 1)));
			}
		}
		template<class T>void IArray<T>::SortRandom(index_t startIndex) { return SortRandom(startIndex, size() - startIndex); }
		template<class T>template<class AnyT, class EqualFunctionType>index_t IArray<T>::IndexOf(AnyT t, index_t startIndex, EqualFunctionType equal)const
		{
			if (CheckIndex(startIndex))return-1;
			T* p(getdata() + startIndex);
			T* pend(getdata() + size());
			while (p != pend)if (equal(*p++, t))return index_t(p - getdata() - 1);
			return -1;
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t IArray<T>::IndexOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equal)const
		{
			if (CheckIndex(startIndex, length))return -1;;
			T* p(getdata() + startIndex);
			T* pend(p + length);
			while (p != pend)if (equal(*p++, t))return index_t(p - getdata() - 1);
			return -1;
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t IArray<T>::LastIndexOf(AnyT t, index_t startIndex, EqualFunctionType equal)const
		{
			if (CheckIndex(startIndex))return -1;
			T* p(getdata() + size());
			T* pend(getdata() + startIndex);
			while (p-- != pend)if (equal(*p, t))return index_t(p - getdata());
			return -1;
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t IArray<T>::LastIndexOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equal)const
		{
			if (CheckIndex(startIndex, length))return -1;
			T* pend(getdata() + startIndex);
			T* p(pend + length);
			while (p-- != pend)if (equal(*p, t))return index_t(p - getdata());
			return -1;
		}
		template<class T>template<class AnyT, class EqualFunctionType>ArrayIterator<T> IArray<T>::Find(AnyT t, index_t startIndex, EqualFunctionType equal)const
		{
			if (CheckIndex(startIndex))return end();
			index_t count(0);
			T*p(getdata() + startIndex);
			T*pend(getdata() + size());
			while (p != pend)if (equal(*p++, t))return ArrayIterator< T>(p - 1);
			return end();
		}
		template<class T>template<class AnyT, class EqualFunctionType>ArrayIterator<T> IArray<T>::Find(AnyT t, index_t startIndex, index_t length, EqualFunctionType equal)const
		{
			if (CheckIndex(startIndex, length))return end();
			index_t count(0);
			T*p(getdata() + startIndex);
			T*pend(p + length);
			while (p != pend)if (equal(*p++, t))return ArrayIterator<T>(p - 1);
			return end();
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t IArray<T>::CountOf(AnyT t, index_t startIndex, EqualFunctionType equal)const
		{
			if (CheckIndex(startIndex))return 0;
			index_t count(0);
			T*p(getdata() + startIndex);
			T*pend(getdata() + size());
			while (p != pend)if (equal(*p++, t))++count;
			return count;
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t IArray<T>::CountOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equal)const
		{
			if (CheckIndex(startIndex, length))return 0;
			index_t count(0);
			T*p(getdata() + startIndex);
			T*pend(p + length);
			while (p != pend)if (equal(*p++, t))++count;
			return count;
		}
		template<class T>T& IArray<T>::FirstElement()
		{
			if (size() == 0)throw PIndexOutOfRangeException();
			return *getdata();
		}
		template<class T>const T& IArray<T>::FirstElement()const
		{
			if (size() == 0)throw PIndexOutOfRangeException();
			return *getdata();
		}
		template<class T>T& IArray<T>::LastElement()
		{
			if (size() == 0)throw PIndexOutOfRangeException();
			return getdata()[size() - 1];
		}
		template<class T>const T& IArray<T>::LastElement()const
		{
			if (size() == 0)throw PIndexOutOfRangeException();
			return getdata()[size() - 1];
		}
		template<class T>template<class AnyT, class CompareFunctionType>index_t IArray<T>::DichotomyInsertAsc(AnyT t, CompareFunctionType compare)
		{
			index_t high = size();
			index_t low = 0;
			index_t i = 0;
			T* p = getdata();
			while (low != high)
			{
				i = (low + high) >> 1;
				index_t result = compare(p[i], t);
				if (result == 0 || low == i)
				{
					if (result < 0)++i;
					break;
				}
				if (result < 0)low = i;
				else high = i;
			}
			Insert(i, t);
			return i;
		}
		template<class T>template<class AnyT, class CompareFunctionType>index_t IArray<T>::DichotomyIndexOf(AnyT t, index_t startIndex, index_t length, CompareFunctionType compare)const
		{
			if (length == 0)return -1;
			if (startIndex < 0 || length < 0)throw PInvalidArgumentException();
			if (startIndex + length > size())throw PIndexOutOfRangeException();
			T*p = getdata();
			index_t result = compare(p[startIndex], t);
			index_t result2 = compare(p[startIndex + length - 1], t);
			if (result == result2) { return result == 0 ? startIndex : -1; }
			if (result == 0)return startIndex;
			if (result2 == 0)return startIndex + length - 1;
			if (length <= 2)return -1;
			result2 = result2 > result ? 1 : -1;
			index_t high = startIndex + length - 2;
			index_t low = startIndex + 1;
			index_t i = low;
			while (low != high)
			{
				i = (low + high) >> 1;
				result = compare(p[i], t);
				if (result == 0)return i;
				if (low == i)
				{
					if (result < 0)++i;
					else return-1;
					break;
				}
				if ((result > 0 && result2 < 0) || (result < 0 && result2>0))low = i;
				else high = i;
			}
			return compare(p[i], t) == 0 ? i : -1;
		}



		//PArray

		//加法重载
		template<class T> T* operator+(PArray<T>& xArray, index_t mov)
		{
			return (T*)xArray + mov;
		}
		template<class T> const T* operator+(const PArray<T>& xArray, index_t mov)
		{
			return (const T*)xArray + mov;
		}
		template<class T> T* operator-(PArray<T>& xArray, index_t mov)
		{
			return (T*)xArray - mov;
		}
		template<class T> const T* operator-(const PArray<T>& xArray, index_t mov)
		{
			return (const T*)xArray - mov;
		}
		template<class T> T* operator+(index_t mov, PArray<T>& xArray)
		{
			return (T*)xArray + mov;
		}
		template<class T> const T* operator+(index_t mov, const PArray<T>& xArray)
		{
			return (const T*)xArray + mov;
		}
		//关系运算符
		template<class T> bool operator==(const PArray<T>& x1, const PArray<T>& x2)
		{
			if (x1.IsNull() && x2.IsNull())return true;
			if (x1.IsNull() || x2.IsNull())return false;
			if (x1.GetLength() != x2.GetLength())return false;
			const T* p1 = x1; const T*pe1 = p1 + x1.GetLength();
			const T* p2 = x2;
			while (p1 != pe1)if (*p1++ != *p2++)return false;
			return true;
		}
		template<class T> bool operator!=(const PArray<T>& x1, const PArray<T>& x2)
		{
			if (x1.IsNull() && x2.IsNull())return false;
			if (x1.IsNull() || x2.IsNull())return true;
			if (x1.GetLength() != x2.GetLength())return true;
			const T* p1 = x1; const T*pe1 = p1 + x1.GetLength();
			const T* p2 = x2;
			while (p1 != pe1)if (*p1++ != *p2++)return true;
			return false;
		}
		template<class T> bool operator>=(const PArray<T>& x1, const PArray<T>& x2)
		{
			if (x1.IsNull() && x2.IsNull())return true;
			if (x1.IsNull() || x2.IsNull())return x2.IsNull();
			const T* p1 = x1; const T*pe1 = p1 + x1.GetLength();
			const T* p2 = x2; const T*pe2 = p2 + x2.GetLength();
			while (p1 != pe1&& pe2 != pe2) { if (*p1 != *p2)break; ++p1; ++p2; }
			if (p1 == pe1)return p2 == pe2;
			if (p2 == pe2)return true;
			return *p1 >= *p2;
		}
		template<class T> bool operator<=(const PArray<T>& x1, const PArray<T>& x2)
		{
			if (x1.IsNull() && x2.IsNull())return true;
			if (x1.IsNull() || x2.IsNull())return x1.IsNull();
			const T* p1 = x1; const T*pe1 = p1 + x1.GetLength();
			const T* p2 = x2; const T*pe2 = p2 + x2.GetLength();
			while (p1 != pe1&& pe2 != pe2) { if (*p1 != *p2)break; ++p1; ++p2; }
			if (p1 == pe1)return p2 != pe2;
			if (p2 == pe2)return false;
			return *p1 <= *p2;
		}
		template<class T> bool operator>(const PArray<T>& x1, const PArray<T>& x2)
		{
			if (x1.IsNull() && x2.IsNull())return false;
			if (x1.IsNull() || x2.IsNull())return x2.IsNull();
			const T* p1 = x1; const T* pe1 = p1 + x1.GetLength();
			const T* p2 = x2; const T* pe2 = p2 + x2.GetLength();
			while (p1 != pe1&& pe2 != pe2) { if (*p1 != *p2)break; ++p1; ++p2; }
			if (p1 == pe1)return false;
			if (p2 == pe2)return true;
			return *p1 > *p2;
		}
		template<class T> bool operator<(const PArray<T>& x1, const PArray<T>& x2)
		{
			if (x1.IsNull() && x2.IsNull())return false;
			if (x1.IsNull() || x2.IsNull())return x1.IsNull();
			const T* p1 = x1; const T*pe1 = p1 + x1.GetLength();
			const T* p2 = x2; const T*pe2 = p2 + x2.GetLength();
			while (p1 != pe1&& pe2 != pe2) { if (*p1 != *p2)break; ++p1; ++p2; }
			if (p1 == pe1)return true;
			if (p2 == pe2)return false;
			return *p1 < *p2;
		}
		//获取该数组的一部分（子数组）
		template<class T>PArray<T> PArray<T>::SubArray(index_t startIndex, index_t length)const
		{
			if (IsNull())throw PPointerIsNullException();
			if (length < 0 || startIndex < 0)throw PInvalidArgumentException();
			if (length + startIndex > GetLength())throw PIndexOutOfRangeException();
			return new LK::Collection::DefaultArray<T>(length, (const T*const&)*this + startIndex);
		}
		//从数据pdata的startIndex元素起复制len个元素形成T作为元素的数组
		template<class T>template<class AnyT>PArray<T> PArray<T>::CopyFrom(const PArray<AnyT>&source)
		{
			if (source.IsNull())return PArray<T>();
			if (source.GetLength() == 0)return new IArray<T>();
			T* p = Memory::Malloc<T>(source.GetLength());
			T* pt(p);
			T* end(p + source.GetLength());
			const AnyT* px(source);
			while (pt != end)placementnew(pt++, *px++);
			return new LK::Collection::DefaultArray<T>(source.GetLength(), p);
		}
		template<class T>template<class AnyT>PArray<T> PArray<T>::CopyFrom(const PArray<AnyT>&source, index_t startIndex)
		{
			if (startIndex < 0)throw PInvalidArgumentException();//参数无效
			if (startIndex > source.GetLength())throw PIndexOutOfRangeException();
			if (source.GetLength() == startIndex)return new IArray<T>();
			T* p = Memory::Malloc<T>(source.GetLength() - startIndex);
			T* pt(p);
			T* end(p + source.GetLength() - startIndex);
			const AnyT* px(source + startIndex);
			while (pt != end)placementnew(pt++, *px++);
			return new LK::Collection::DefaultArray<T>(source.GetLength() - startIndex, p);
		}
		template<class T>template<class AnyT>PArray<T> PArray<T>::CopyFrom(const PArray<AnyT>&source, index_t startIndex, index_t length)
		{
			if (startIndex < 0 || length < 0)throw PInvalidArgumentException();//参数无效
			if (startIndex + length > source.GetLength())throw PIndexOutOfRangeException();
			if (!length)return new IArray<T>();
			T* p = Memory::Malloc<T>(length);
			T* pt(p);
			T* end(p + length);
			const AnyT* px(source + startIndex);
			while (pt != end)placementnew(pt++, *px++);
			return new LK::Collection::DefaultArray<T>(length, p);
		}
		//从数据pdata的startByte字节处复制len个字节形成数组
		template<class T>template<class AnyT>PArray<T> PArray<T>::CopyFromByBytes(const PArray<AnyT>&source)
		{
			if (source.GetLength() == 0)return new IArray<T>();
			T* p = Memory::Malloc<T>(((sizeof(AnyT)*source.GetLength()) % sizeof(T)) ? sizeof(AnyT)*source.GetLength() / sizeof(T) + 1 : sizeof(AnyT)*source.GetLength() / sizeof(T));
			Memory::Copy(p, (const AnyT*)source, source.GetLengthOfBytes());
			return new LK::Collection::DefaultArray<T>((source.GetLengthOfBytes() % sizeof(T)) ? source.GetLengthOfBytes() / sizeof(T) + 1 : source.GetLengthOfBytes() / sizeof(T), p);
		}
		template<class T>template<class AnyT>PArray<T> PArray<T>::CopyFromByBytes(const PArray<AnyT>&source, index_t startByte)
		{
			if (startByte < 0)throw PInvalidArgumentException();//参数无效
			if (startByte > source.GetLengthOfBytes())throw PIndexOutOfRangeException();//参数无效
			if (startByte == source.GetLengthOfBytes())return new IArray<T>();
			T* p = Memory::Malloc<T>(((source.GetLengthOfBytes() - startByte) % sizeof(T)) ? (source.GetLengthOfBytes() - startByte) / sizeof(T) + 1 : (source.GetLengthOfBytes() - startByte) / sizeof(T));
			Memory::Copy(p, (const AnyT*)source, sizeof(AnyT)*source.GetLength() - startByte);
			return new LK::Collection::DefaultArray<T>(((source.GetLengthOfBytes() - startByte) % sizeof(T)) ? (source.GetLengthOfBytes() - startByte) / sizeof(T) + 1 : (source.GetLengthOfBytes() - startByte) / sizeof(T), p);
		}
		template<class T>template<class AnyT>PArray<T> PArray<T>::CopyFromByBytes(const PArray<AnyT>&source, index_t startByte, index_t lengthOfBytes)
		{
			if (startByte < 0 || lengthOfBytes < 0)throw PInvalidArgumentException();//参数无效
			if (startByte + lengthOfBytes > source.GetLengthOfBytes())throw PIndexOutOfRangeException();//参数无效
			if (!lengthOfBytes)return new IArray<T>();
			T* p = Memory::Malloc<T>((lengthOfBytes%sizeof(T)) ? lengthOfBytes / sizeof(T) + 1 : lengthOfBytes / sizeof(T));
			Memory::Copy(p, source, lengthOfBytes);
			return new LK::Collection::DefaultArray<T>((lengthOfBytes%sizeof(T)) ? lengthOfBytes / sizeof(T) + 1 : lengthOfBytes / sizeof(T), p);
		}
		//将该数组的内容复制一部分到另一个数组
		template<class T>template<class AnyT>index_t PArray<T>::CopyTo(PArray<AnyT>& destination, index_t sourceIndex, index_t destinationIndex)const
		{
			if (sourceIndex < 0 || destinationIndex < 0)throw PInvalidArgumentException();//参数无效
			if (sourceIndex > GetLength() || destinationIndex > destination.GetLength())throw PIndexOutOfRangeException();
			index_t length = (GetLength() - sourceIndex > destination.GetLength() - destinationIndex) ? destination.GetLength() - destinationIndex : GetLength() - sourceIndex;
			const T* p = *this + sourceIndex;
			T* pEnd = p + length;
			AnyT* pd = destination + destinationIndex;
			while (p < pEnd) { *pd = *p; ++p; ++pd; }//强制转换
			return length;
		}
		template<class T>template<class AnyT>index_t PArray<T>::CopyTo(PArray<AnyT>& destination, index_t sourceIndex, index_t destinationIndex, index_t length)const
		{
			if (sourceIndex < 0 || destinationIndex < 0 || length < 0)throw PInvalidArgumentException();//参数无效
			if (sourceIndex + length > GetLength() || destinationIndex + length > destination.GetLength())throw PIndexOutOfRangeException();
			const T* p = *this + sourceIndex;
			const T* pEnd = p + length;
			AnyT* pd = destination + destinationIndex;
			while (p < pEnd) { *pd = *p; ++p; ++pd; }//强制转换
			return length;
		}
		//向任意一种类型的数组复制一定的字节数
		template<class T>template<class AnyT>index_t PArray<T>::CopyToByBytes(PArray<AnyT>& dest, index_t sourceByte, index_t destinationByte)const
		{
			if (sourceByte < 0 || destinationByte < 0)throw PInvalidArgumentException();//参数无效
			if (sourceByte > GetLengthOfBytes() || destinationByte > dest.GetLengthOfBytes())throw PIndexOutOfRangeException();
			index_t lengthOfByte = (GetLengthOfBytes() - sourceByte > dest.GetLengthOfBytes() - destinationByte) ? dest.GetLengthOfBytes() - destinationByte : GetLengthOfBytes() - sourceByte;
			Memory::Copy(((unsigned char*)(AnyT*)dest) + destinationByte, ((unsigned char*)*this) + sourceByte, lengthOfByte);
			return lengthOfByte;
		}
		template<class T>template<class AnyT>index_t PArray<T>::CopyToByBytes(PArray<AnyT>& dest, index_t sourceByte, index_t destinationByte, index_t lengthOfByte)const
		{
			if (sourceByte < 0 || destinationByte < 0 || lengthOfByte < 0)throw PInvalidArgumentException();//参数无效
			if (sourceByte + lengthOfByte > GetLengthOfBytes() || lengthOfByte + destinationByte > dest.GetLengthOfBytes())throw PIndexOutOfRangeException();
			Memory::Copy(((unsigned char*)(AnyT*)dest) + destinationByte, ((unsigned char*)*this) + sourceByte, lengthOfByte);
			return lengthOfByte;
		}


		//数组的默认实现

		template<class T>struct PDefaultArray :PArray<T>
		{
		public:
			typedef DefaultArray<T> vArray;
			PMETHODS(PDefaultArray, vArray)
				static void AddTypeInfo();
		};
		template<class T>struct DefaultArray :public IArray<T>
		{
		public:
			typedef PDefaultArray<T> xArray;
			BMETHODS(xArray, DefaultArray)
				/**
				@brief 当前最大元素数*/
				index_t MaxSize;
			/**
			@brief 最大允许未使用空间数*/
			index_t MaxUnusedLength;
			/**
			@brief 当前元素数量*/
			index_t Length;
			/**
			@brief 获取元素数*/
			index_t size()const { return Length; }
			/**
			@brief 获取数组当前最大容量
			@note 当数组元素数不大于最大容量，而且两者之差不大于MaxUnusedLength时，对象存储区域将不会进行内存的重新调整*/
			index_t GetMaxSize()const { return MaxSize; }
			/**
			@brief 默认最大允许未使用空间数*/
			static const index_t DefMaxUnusedLength = index_t(1ull << (sizeof(index_t) * 8 - 2));
			/**
			@brief 长度检查，len为负将抛出异常*/
			static void CheckLength(index_t len) { if (len < 0)throw PInvalidArgumentException(L"数组长度不可以为负值"); }
			/*
			@brief 数据记录器区*/
			T* data;
			/**
			@brief 返回一个浅表副本*/
			DefaultArray* Clone()const { return new DefaultArray(*this); }
			/**
			@brief 获取数组内容首地址*/
			virtual void const* GetData()const { return data; }
			/**
			@brief 调整大小，返回调整后数组元素最大大小
			@note 如果len<0将抛出异常*/
			index_t Resize(index_t len)
			{
				CheckLength(len);
				if (len > Length)
				{
					T* p;
					if (len > MaxSize)
					{
						p = Memory::template Malloc<T>(len, (size_t*)&MaxSize);
#if LK_ARRAY_SAFE_MASK
						u8* pb = (u8*)p;
						for (size_t i = 0; i < MaxSize*sizeof(T); ++i)
							pb[i] = LK_ARRAY_SAFE_MASK;
#endif
						IArrays::MoveConstruct<T, T>(p, data, Length);
						IArrays::DefaultConstruct<T>(p + Length, len - Length);
#if LK_ARRAY_SAFE_MASK
						pb = (u8*)data;
						for (size_t i = 0; i < Length*sizeof(T); ++i)
							pb[i] = LK_ARRAY_SAFE_MASK;
#endif
						Memory::Free(data);
						data = p;
					}
					else
					{
						p = IArray<T>::getdata();
						IArrays::DefaultConstruct(p + Length, len - Length);
					}
				}
				else if (len < Length)
				{
					if (MaxSize - len>MaxUnusedLength)
					{
						T* p = Memory::template Malloc<T>(len, (size_t*)&MaxSize);
#if LK_ARRAY_SAFE_MASK
						u8* pb = (u8*)p;
						for (size_t i = 0; i < MaxSize*sizeof(T); ++i)
							pb[i] = LK_ARRAY_SAFE_MASK;
#endif
						IArrays::MoveConstruct(p, data, len);
						IArrays::Deconstruct(data + len, Length - len);
#if LK_ARRAY_SAFE_MASK
						pb = (u8*)data;
						for (size_t i = 0; i < Length*sizeof(T); ++i)
							pb[i] = LK_ARRAY_SAFE_MASK;
#endif
						Memory::Free(data);
						data = p;
					}
					else
					{
						IArrays::Deconstruct(data + len, Length - len);
#if LK_ARRAY_SAFE_MASK
						u8* pb = (u8*)(data + len);
						for (size_t i = 0; i < (Length - len)*sizeof(T); ++i)
							pb[i] = LK_ARRAY_SAFE_MASK;
#endif
					}
				}
				Length = len;
				return MaxSize;
			}
			/**
			@brief 默认构造函数，构造一个空DefaultArray数组*/
			DefaultArray() : MaxSize(0), MaxUnusedLength(DefMaxUnusedLength), Length(0), data(NULL) {}
			/**
			@brief 传入数组长度，构造一个未初始化的数组
			@note 当指定数组长度length小于0时，将抛出异常*/
			DefaultArray(index_t length) :MaxSize(0), MaxUnusedLength(DefMaxUnusedLength), Length(0), data(NULL)
			{
				Resize(length);
			}
			/**
			@brief 从初始化列表进行构造*/
#ifdef _INITIALIZER_LIST_//初始化列表支持
			DefaultArray(std::initializer_list<T> const& lst) :MaxUnusedLength(DefMaxUnusedLength), Length(0), MaxSize(0), data(NULL)
			{
				for (auto const&a : lst)IArray::Append(a);
			}
#endif
			/**
			@brief 复制构造函数
			@note 新数组的类型将是DefaultArray*/
			DefaultArray(const IArray<T>&vfa) :MaxUnusedLength(DefMaxUnusedLength)
			{
				data = Memory::template Malloc<T>(vfa.Length, (size_t*)&MaxSize);
				IArrays::Construct(data, vfa.getdata(), Length = vfa.Length);
			}
			/**
			@brief 复制构造函数
			@note 新数组的类型将是DefaultArray*/
			DefaultArray(const DefaultArray&vfa) :MaxUnusedLength(vfa.MaxUnusedLength)
			{
				data = Memory::template Malloc<T>(vfa.Length, (size_t*)&MaxSize);
				IArrays::Construct(data, vfa.getdata(), Length = vfa.Length);
			}
			DefaultArray&operator=(const IArray<T>&vfa)
			{
				Resize(vfa.size());
				T*p = vfa.getdata();
				for (index_t i = 0; i < Length; ++i)data[i] = p[i];
				return *this;
			}
			DefaultArray&operator=(const DefaultArray&vfa)
			{
				Resize(vfa.Length);
				for (index_t i = 0; i < Length; ++i)data[i] = vfa.data[i];
				return *this;
			}
#ifdef SUPPORT_RIGHT_VALUE_REFERENCE
			/**
			@brief 移动构造函数
			@note 新数组的类型将是DefaultArray*/
			DefaultArray(DefaultArray&&vfa) :MaxSize(vfa.MaxSize), MaxUnusedLength(vfa.MaxUnusedLength), Length(vfa.Length), data(vfa.data)
			{
				vfa.data = NULL;
				vfa.Length = 0;
				vfa.MaxSize = 0;
			}
			DefaultArray&operator=(DefaultArray&&vfa)
			{
				Object::Swap(Length, vfa.Length);
				Object::Swap(data, vfa.data);
				Object::Swap(MaxSize, vfa.MaxSize);
				Object::Swap(MaxUnusedLength, vfa.MaxUnusedLength);
				return *this;
			}
#endif
			/**
			@brief 传入数组元素，并使用一个参考元素来初始化所有元素
			@param [传入]参数len表示数组元素数
			@param [传入]参数t为参考元素
			@note 当指定数组长度len小于0时，将抛出异常*/
			DefaultArray(index_t len, const T&t) :MaxUnusedLength(DefMaxUnusedLength)
			{
				CheckLength(len);
				data = Memory::template Malloc<T>(len, (size_t*)&MaxSize);
				IArrays::ConstructWith(data, t, Length = len);
			}
			/**
			@brief 使用迭代器构造，如果迭代器所表示内容多于MaxSize，则只取前MaxSize个内容来构造
			@note 迭代器类型必须要通过typedef或者using定义value_type成员*/
			template<class IT>DefaultArray(const IT&first, const IT&end, typename UseIf<IsConvertible<typename IT::value_type, T>::V>::T*p = NULL) :data(NULL), MaxUnusedLength(DefMaxUnusedLength)
			{
				Length = 0; IT it = first; while (it != end) { if (Length == MaxSize)break; IArray<T>::template Append<typename IT::value_type>(*it); ++it; }
			}
			/**
			@brief 直接传入元素数和指针来构造数组
			@param [传入]参数len用以指定元素数
			@param [传入]参数p指向存放空间
			@note 若len<0或len>MaxSize将抛出异常，如果p为NULL进行默认初始化*/
			DefaultArray(index_t len, const T*p) : MaxSize(0), MaxUnusedLength(DefMaxUnusedLength), Length(len), data(NULL)
			{
				CheckLength(Length); data = Memory::template Malloc<T>(len, (size_t*)&MaxSize); if (p)IArrays::Construct(data, p, len); else IArrays::DefaultConstruct(data, len);
			}
			/**
			@brief 从C-Style数组进行复制构造*/
			template<class TT>DefaultArray(const TT&arr, typename UseIf<IsArray<TT>::V>::T*p = NULL) : data(NULL), MaxSize(0), MaxUnusedLength(DefMaxUnusedLength)
			{
				CheckLength(Length = IsArray<TT>::C); data = Memory::template Malloc<TT>(Length, (size_t*)&MaxSize); if (p)IArrays::Construct(data, arr, Length);
			}
			/**
			@brief 析构函数，数据清理*/
			~DefaultArray()
			{
				IArrays::Deconstruct(data, Length);
				Memory::Free(data);
				data = NULL;
				MaxSize = Length = 0;
			}
		};
		/**
		@brief 传入数组长度，构造一个未初始化的数组
		@param [传入]参数len表示新建数组元素数*/
		template<class T>PArray<T>::PArray(index_t len) :PArrays(new DefaultArray<T>(len)) {}
		/**
		@brief 传入数组元素，并使用一个参考元素来初始化所有元素
		@param [传入]参数len表示数组元素数
		@param [传入]参数t为参考元素*/
		template<class T>PArray<T>::PArray(index_t len, const T&t) : PArrays(new DefaultArray<T>(len, t)) {}
		/**
		@brief 使用迭代器构造一个LK::Collection::DefaultArray*/
		template<class T>template<class IT>PArray<T>::PArray(const IT&first, const IT&end) : PArrays(new DefaultArray<T>(first, end)) {}
		/**
		@brief 传入元素数和指针来复制构造数组
		@param [传入]参数len用以指定元素数
		@param [传入]参数p指向存放空间*/
		template<class T>PArray<T>::PArray(index_t len, T* p) : PArrays(new DefaultArray<T>(len, p)) {}

	}
}
